querysub 0.503.0 → 0.505.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.503.0",
+  "version": "0.505.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/3-path-functions/pathFunctionLoader.ts

@@ -177,7 +177,7 @@ let moduleResolver = async (spec: {
             await executeCommand("git", ["reset", "--hard", spec.gitRef], { cwd: repoPath });
 
             // Yarn install
-            await executeCommand("yarn", ["install", "--mutex", "network"], { cwd: repoPath });
+            await yarnInstallWithHealing(repoPath);
 
             // Delete querysub, and replace it with a symlink. Otherwise the synchronization code
             //  will run again, and a lot of setup code will run again, etc, and nothing will work correctly.
@@ -462,6 +462,22 @@ const hotreloadIfChanged = batchFunction({ delay: 100, name: "hotreloadIfChanged
     }
 });
 
+// A corrupt entry in the shared global yarn cache (e.g. "Extracting tar content ... the file appears to be
+//  corrupt") fails every install identically, because re-cloning the repo folder never touches the global
+//  cache. Detect that, purge the cache with `yarn cache clean`, and retry once so the loader heals itself.
+async function yarnInstallWithHealing(repoPath: string): Promise<void> {
+    try {
+        await executeCommand("yarn", ["install", "--mutex", "network"], { cwd: repoPath });
+        return;
+    } catch (e) {
+        let errorText = String((e as Error)?.stack || e);
+        if (!/appears to be corrupt|Extracting tar content/.test(errorText)) throw e;
+        console.log(red(`yarn install failed with a corrupt yarn cache, cleaning cache and retrying:\n${errorText}`));
+        await executeCommand("yarn", ["cache", "clean"]);
+    }
+    await executeCommand("yarn", ["install", "--mutex", "network"], { cwd: repoPath });
+}
+
 async function which(command: string): Promise<string> {
     let whichOrWhere = os.platform() === "win32" ? "where" : "which";
     let path = child_process.execSync(`${whichOrWhere} ${command}`).toString().trim().replaceAll("\r", "").split("\n")[0].trim().replaceAll("\\", "/");

package/src/diagnostics/logs/errorTickets/TicketPage.tsx

@@ -7,16 +7,18 @@ import { nextId, sort } from "socket-function/src/misc";
 import { formatDateTime, formatTime } from "socket-function/src/formatting/format";
 import { Querysub } from "../../../4-querysub/Querysub";
 import { URLParam } from "../../../library-components/URLParam";
+import { mainResets } from "../../../library-components/urlResetGroups";
 import { ATag } from "../../../library-components/ATag";
 import { Button } from "../../../library-components/Button";
+import { InputLabel } from "../../../library-components/InputLabel";
 import { LogDatum } from "../diskLogger";
 import { managementPageURL, showingManagementURL } from "../../managementPages";
 import { TicketsController, watchTickets } from "./tickets";
 import { isTicketFinished, Ticket, TicketComment, TicketPatchFile, TicketState, TICKET_STATES } from "./ticketTypes";
 
 export const ticketIdURL = new URLParam("ticketid", "");
-// "unfinished" hides tickets in a final state (fixed / not-a-bug).
-export const ticketFilterURL = new URLParam("ticketfilter", "");
+// "unfinished" hides tickets in a final state (fixed / not-a-bug). Resets when the page changes, so the filter doesn't confusingly stick around.
+export const ticketFilterURL = new URLParam("ticketfilter", "", { reset: [mainResets] });
 
 const TITLE_MAX_LENGTH = 200;
 const COMMENT_TEXTAREA_MIN_HEIGHT = 250;
@@ -183,6 +185,11 @@ export class TicketPage extends qreact.Component {
 }
 
 class TicketList extends qreact.Component {
+    state = t.state({
+        newTicketTitle: t.atomic<string>(""),
+        newTicketText: t.atomic<string>(""),
+    });
+
     render() {
         let tickets = getController().getTickets();
         if (!tickets) {
@@ -199,7 +206,7 @@ class TicketList extends qreact.Component {
         return <div className={css.vbox(16).pad2(16).fillBoth.minHeight(0)}>
             <div className={css.hbox(16)}>
                 <h2>Tickets ({sorted.length}{showUnfinishedOnly && " unfinished" || ""})</h2>
-                <ATag values={[ticketFilterURL.getOverride(showUnfinishedOnly && "" || "unfinished")]}>
+                <ATag values={[ticketFilterURL.getOverride(showUnfinishedOnly ? "" : "unfinished")]}>
                     {showUnfinishedOnly && "Show All" || "Show Unfinished Only"}
                 </ATag>
                 <Button
@@ -216,6 +223,65 @@ class TicketList extends qreact.Component {
                 <code className={css.pad2(8, 4).hsl(220, 15, 15).colorhsl(120, 60, 70).fontSize(13).borderRadius(3)}>yarn autofix</code>
                 <span>to automatically investigate and fix open tickets.</span>
             </div>
+            <div className={css.vbox(8).pad2(12).bord2(210, 50, 60).hsl(210, 50, 96).fillWidth}>
+                <strong>Create Custom Ticket</strong>
+                <InputLabel
+                    label="Title"
+                    className={css.width(600)}
+                    value={this.state.newTicketTitle}
+                    onChangeValue={(value) => {
+                        this.state.newTicketTitle = value;
+                    }}
+                />
+                <textarea
+                    className={css.minHeight(COMMENT_TEXTAREA_COLLAPSED_HEIGHT).minHeight(COMMENT_TEXTAREA_MIN_HEIGHT, "focus").fillWidth.pad2(8).fontSize(14).resize("vertical")}
+                    value={this.state.newTicketText}
+                    onInput={e => {
+                        this.state.newTicketText = (e.target as HTMLTextAreaElement).value;
+                    }}
+                />
+                <div className={css.hbox(8)}>
+                    <Button
+                        hue={210}
+                        onClick={() => {
+                            let title = this.state.newTicketTitle.trim();
+                            let text = this.state.newTicketText.trim();
+                            if (!title) return;
+                            Querysub.onCommitFinished(async () => {
+                                let now = Date.now();
+                                let ticket: Ticket = {
+                                    id: nextId(),
+                                    title: title.slice(0, TITLE_MAX_LENGTH),
+                                    state: "investigation",
+                                    createdTime: now,
+                                    lastUpdatedTime: now,
+                                    errorDatum: {
+                                        time: now,
+                                        __LOG_TYPE: "custom",
+                                        param0: title,
+                                    },
+                                    comments: !text && [] || [{
+                                        id: nextId(),
+                                        time: now,
+                                        author: "user",
+                                        kind: "text" as const,
+                                        text,
+                                    }],
+                                };
+                                await getController().createTicket.promise(ticket);
+                                resetTicketData();
+                                Querysub.commit(() => {
+                                    this.state.newTicketTitle = "";
+                                    this.state.newTicketText = "";
+                                    goToTicket(ticket.id);
+                                });
+                            });
+                        }}
+                    >
+                        Create Ticket
+                    </Button>
+                </div>
+            </div>
             {sorted.length === 0 && <div>No tickets. Create one from the Error Notifications page with the "Ticket" button.</div>}
             <div className={css.vbox(8).fillWidth.flexGrow(1).minHeight(0).overflowAuto}>
                 {sorted.map(ticket => (

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

@@ -161,34 +161,24 @@ async function registerWithTicketService() {
     }
 }
 
-async function applyPatch(ticketId: string, commentId: string): Promise<void> {
-    let service = await ticketService();
-    let ticket = await service.getTicket(ticketId);
-    if (!ticket) {
-        throw new Error(`Ticket ${ticketId} not found`);
-    }
-    let comment = ticket.comments.find(c => c.id === commentId);
-    if (!comment || comment.kind !== "patch" || !comment.patchFiles) {
-        throw new Error(`Comment ${commentId} is not a patch comment on ticket ${ticketId}`);
-    }
-
-    // Relative paths may belong to either the application repo or the querysub repo (a sibling / dependency) — file paths are unique across the two, so whichever one actually has the file wins.
-    function resolvePatchFilePath(file: string): { fullPath: string | undefined; candidates: string[] } {
-        let candidates = Array.from(new Set([
-            path.resolve(process.cwd(), file),
-            path.resolve(QUERYSUB_ROOT, file),
-        ]));
-        for (let candidate of candidates) {
-            if (fs.existsSync(candidate)) {
-                return { fullPath: candidate, candidates };
-            }
+// Relative paths may belong to either the application repo or the querysub repo (a sibling / dependency) — file paths are unique across the two, so whichever one actually has the file wins.
+function resolvePatchFilePath(file: string): { fullPath: string | undefined; candidates: string[] } {
+    let candidates = Array.from(new Set([
+        path.resolve(process.cwd(), file),
+        path.resolve(QUERYSUB_ROOT, file),
+    ]));
+    for (let candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return { fullPath: candidate, candidates };
         }
-        return { fullPath: undefined, candidates };
     }
+    return { fullPath: undefined, candidates };
+}
 
-    // Validate everything before writing anything, so a patch is all-or-nothing.
+// Resolves and validates every file entry without writing anything (so a patch is all-or-nothing), returning the writes to perform. Throws with a detailed message when the patch cannot apply cleanly — also used at addPatch time so the AI is told about mistakes immediately.
+function preparePatchWrites(patchFiles: TicketPatchFile[]): { fullPath: string; newContents: string }[] {
     let writes: { fullPath: string; newContents: string }[] = [];
-    for (let patchFile of comment.patchFiles) {
+    for (let patchFile of patchFiles) {
         let { fullPath, candidates } = resolvePatchFilePath(patchFile.file);
         if (!patchFile.oldText) {
             if (fullPath && fs.readFileSync(fullPath, "utf8").trim()) {
@@ -203,11 +193,29 @@ async function applyPatch(ticketId: string, commentId: string): Promise<void> {
         let contents = fs.readFileSync(fullPath, "utf8");
         let index = contents.indexOf(patchFile.oldText);
         if (index === -1) {
-            throw new Error(`Patch oldText not found in ${patchFile.file}. The file may have changed since the patch was created.`);
+            throw new Error(`Patch oldText not found in ${fullPath}. oldText must be copied EXACTLY from the current file contents (check whitespace/indentation).`);
+        }
+        if (contents.indexOf(patchFile.oldText, index + 1) !== -1) {
+            throw new Error(`Patch oldText appears more than once in ${fullPath}, so the replacement is ambiguous. Include more surrounding context to make it unique.`);
         }
         let newContents = contents.slice(0, index) + patchFile.newText + contents.slice(index + patchFile.oldText.length);
         writes.push({ fullPath, newContents });
     }
+    return writes;
+}
+
+async function applyPatch(ticketId: string, commentId: string): Promise<void> {
+    let service = await ticketService();
+    let ticket = await service.getTicket(ticketId);
+    if (!ticket) {
+        throw new Error(`Ticket ${ticketId} not found`);
+    }
+    let comment = ticket.comments.find(c => c.id === commentId);
+    if (!comment || comment.kind !== "patch" || !comment.patchFiles) {
+        throw new Error(`Comment ${commentId} is not a patch comment on ticket ${ticketId}`);
+    }
+
+    let writes = preparePatchWrites(comment.patchFiles);
     for (let write of writes) {
         fs.mkdirSync(path.dirname(write.fullPath), { recursive: true });
         fs.writeFileSync(write.fullPath, write.newContents);
@@ -272,7 +280,7 @@ Query syntax (case-insensitive substring match by default):
     },
     {
         name: "addPatch",
-        description: `Propose a code patch on the ticket. The patch is NOT applied automatically — a human reviews it and applies or rejects it. Each file entry replaces the first exact occurrence of oldText with newText. oldText must be copied exactly from the current file contents and should be unique within the file. An empty oldText creates a new file with newText as its contents.`,
+        description: `Propose a code patch on the ticket. The patch is NOT applied automatically — a human reviews it and applies or rejects it. Each file entry replaces the exact occurrence of oldText with newText. oldText must be copied exactly from the current file contents and must be unique within the file. An empty oldText creates a new file with newText as its contents. The patch is validated against the current files when you submit it — if validation fails you get an error explaining why and the patch is not added; fix it and resubmit.`,
         inputSchema: {
             type: "object",
             properties: {
@@ -373,6 +381,11 @@ async function callTool(toolName: string, args: Record<string, unknown>): Promis
                 throw new Error(`Each patch file entry requires file, oldText, and newText`);
             }
         }
+        try {
+            preparePatchWrites(files);
+        } catch (e) {
+            throw new Error(`Patch validation failed — the patch was NOT added. Fix the problem and call addPatch again. ${(e as Error).message}`);
+        }
         await addTicketComment(ticketId, {
             kind: "patch",
             text,
@@ -572,6 +585,21 @@ const QUERYSUB_ROOT = path.resolve(__dirname, "../../../..");
 // Set for the duration of a claude run; called whenever a turn finishes (a stream-json "result" event), so the run loop can decide to forward new user comments or end the session.
 let claudeTurnEndedHandler: (() => void) | undefined = undefined;
 
+// Built-in tools (Read/Glob/Grep) don't go through our MCP server, so we record them from the stream instead: tool_use blocks are stashed here until their tool_result arrives in a "user" event. Our own mcp__autofixer__ tools are excluded — callTool already records those.
+let pendingStreamToolCalls = new Map<string, { name: string; input: string; startTime: number }>();
+
+function toolResultToText(content: unknown): string {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+        return content.map(block =>
+            block && typeof block === "object" && (block as { type?: string; text?: string }).type === "text"
+                ? String((block as { text?: string }).text ?? "")
+                : JSON.stringify(block)
+        ).join("\n");
+    }
+    return JSON.stringify(content);
+}
+
 type ClaudeUsage = {
     input_tokens?: number;
     cache_creation_input_tokens?: number;
@@ -608,6 +636,13 @@ function handleClaudeStreamLine(line: string): boolean {
                 console.log(`[claude] ${String(block.text).slice(0, CLAUDE_LOG_PREVIEW_CHARS)}`);
             } else if (block.type === "tool_use") {
                 console.log(`[claude] tool_use: ${blue(String(block.name))} ${JSON.stringify(block.input ?? {}).slice(0, CLAUDE_LOG_PREVIEW_CHARS)}`);
+                if (block.id && !String(block.name).startsWith("mcp__autofixer__")) {
+                    pendingStreamToolCalls.set(String(block.id), {
+                        name: String(block.name),
+                        input: JSON.stringify(block.input ?? {}),
+                        startTime: Date.now(),
+                    });
+                }
             }
         }
         return true;
@@ -621,8 +656,37 @@ function handleClaudeStreamLine(line: string): boolean {
         claudeTurnEndedHandler?.();
         return true;
     }
-    if (event.type === "system" || event.type === "user") {
-        // Init/config noise and tool results (which we already record in the ticket).
+    if (event.type === "user") {
+        // Tool results for built-in tools — record them in the ticket like our own tool calls.
+        for (let block of event.message?.content ?? []) {
+            if (block?.type !== "tool_result" || !block.tool_use_id) continue;
+            let pending = pendingStreamToolCalls.get(String(block.tool_use_id));
+            if (!pending) continue;
+            pendingStreamToolCalls.delete(String(block.tool_use_id));
+            let ticketId = currentTicketId;
+            if (!ticketId) continue;
+            let outputText = toolResultToText(block.content);
+            if (block.is_error) {
+                outputText = `ERROR: ${outputText}`;
+            }
+            if (outputText.length > MAX_TOOL_OUTPUT_STORED) {
+                outputText = outputText.slice(0, MAX_TOOL_OUTPUT_STORED) + `... (truncated, ${outputText.length} chars total)`;
+            }
+            addTicketComment(ticketId, {
+                kind: "tool-call",
+                text: "",
+                toolName: pending.name,
+                toolInput: pending.input,
+                toolOutput: outputText,
+                toolDurationMs: Date.now() - pending.startTime,
+            }).catch(e => {
+                console.error(`Failed to record tool call in ticket ${ticketId}:`, (e as Error).stack ?? e);
+            });
+        }
+        return true;
+    }
+    if (event.type === "system") {
+        // Init/config noise.
         return true;
     }
     return false;
@@ -759,6 +823,7 @@ async function runInvestigation(ticket: Ticket): Promise<void> {
     currentTicketTitle = ticket.title;
     currentTicketStartTime = Date.now();
     runTokens = emptyTokens();
+    pendingStreamToolCalls.clear();
     stateChangedDuringRun = false;
     patchAddedDuringRun = false;
     try {