create-kudzu 0.1.157 → 0.1.159

package/README.md

@@ -16,7 +16,7 @@ Use `--no-install` to create the files without installing dependencies.
 
 ## Optional AI authoring guidance
 
-`create-kudzu@0.1.157` provides optional local AI developer tools with managed check cancellation:
+`create-kudzu@0.1.159` provides optional local AI developer tools with managed check cancellation:
 
 ```bash
 npm create kudzu@latest my-app -- --ai
@@ -59,9 +59,10 @@ npm run ai -- check --timeout-ms 600000
   `ps` PID/parent-PID inspection to stop only that check's descendant snapshot,
   preserving sibling work; inspection errors are reported as failures.
 - Full stdout/stderr are retained in a unique `.kudzu-ai/check-*/output.log`.
-  Large logs show the first/last 2,048 bytes with an omission marker; an error may
-  be in the omitted middle. Read the full log when needed. Old logs are not deleted
-  automatically; remove `.kudzu-ai/` when no longer needed.
+  Long successful checks return only the last 512 bytes. Failed checks return
+  bounded head/tail excerpts and the first recognized diagnostic in the first
+  MiB when present. Read the full log if the excerpt is insufficient. Old logs
+  are not deleted automatically; remove `.kudzu-ai/` when no longer needed.
 - The tool does not cache checks or certify browser behavior. Later edits require
   a new check. Scripts that intentionally detach background jobs or custom
   deployment rules need their own lifecycle/asset handling. Use

package/ai.mjs

@@ -58,7 +58,7 @@ export async function check(root, timeoutMs = 300000) {
           const pids = [managed ? child.pid : -child.pid]
           if (managed) {
             // Keep the outer group alive on this tool's timeout; stop only its ordinary descendants.
-            const table = spawnSync("ps", ["-A", "-o", "pid=", "-o", "ppid="], { encoding: "utf8", timeout: 1000, maxBuffer: 1024 * 1024 })
+            const table = spawnSync("ps", ["-A", "-o", "pid=", "-o", "ppid="], { encoding: "utf8", timeout: 5000, maxBuffer: 1024 * 1024 })
             if (table.status !== 0) error = table.error?.message || table.stderr?.trim() || "Could not inspect managed check descendants"
             else {
               const parents = table.stdout.trim().split("\n").map(line => line.trim().split(/\s+/).map(Number))
@@ -85,21 +85,41 @@ export async function check(root, timeoutMs = 300000) {
       })
     })
     const { size } = await log.stat()
-    const buffer = Buffer.alloc(Math.min(size, 4096))
-    // ponytail: bounded head/tail is an excerpt, never a substitute for the retained full log.
+    const passed = result.exitCode === 0 && !result.timedOut && !result.interrupted && !result.error
+    const limit = passed ? 512 : 4096
+    const buffer = Buffer.alloc(Math.min(size, limit))
+    // ponytail: a bounded excerpt never substitutes for the retained full log.
     let excerpt
-    if (size <= 4096) {
+    if (size <= limit) {
       const { bytesRead } = await log.read(buffer, 0, buffer.length, 0)
       excerpt = buffer.subarray(0, bytesRead).toString("utf8")
+    } else if (passed) {
+      await log.read(buffer, 0, limit, size - limit)
+      excerpt = buffer.toString("utf8")
     } else {
-      await log.read(buffer, 0, 2048, 0)
-      await log.read(buffer, 2048, 2048, size - 2048)
-      excerpt = buffer.subarray(0, 2048).toString("utf8") + "\n[... omitted; read full output.log ...]\n" + buffer.subarray(2048).toString("utf8")
+      const middle = Buffer.alloc(8192)
+      let diagnostic = ""
+      // ponytail: scan at most the first MiB for a useful error; the full log stays on disk.
+      for (let offset = 2048; offset < Math.min(size - 2048, 1 << 20); offset += middle.length - 128) {
+        const length = Math.min(middle.length, size - 2048 - offset)
+        await log.read(middle, 0, length, offset)
+        const text = middle.subarray(0, length).toString("utf8")
+        const match = /(?:\berror(?: TS\d{4})?|\bfailed)\s*:|\bTS\d{4}\s*:|✖/i.exec(text)
+        if (!match) continue
+        const start = Math.max(text.lastIndexOf("\n", match.index) + 1, match.index - 120)
+        const end = text.indexOf("\n", match.index)
+        diagnostic = text.slice(start, end < 0 ? match.index + 240 : Math.min(end, match.index + 240)).trim()
+        break
+      }
+      const edge = diagnostic ? 1536 : 2048
+      await log.read(buffer, 0, edge, 0)
+      await log.read(buffer, edge, edge, size - edge)
+      excerpt = buffer.subarray(0, edge).toString("utf8") + "\n[... omitted; read full output.log ...]\n" + (diagnostic ? diagnostic.slice(0, 400) + "\n[... omitted ...]\n" : "") + buffer.subarray(edge, edge * 2).toString("utf8")
     }
     return {
-      command: "npm run check", passed: result.exitCode === 0 && !result.timedOut && !result.interrupted && !result.error,
+      command: "npm run check", passed,
       ...result, elapsedMs: Math.round(performance.now() - start),
-      log: { path, bytes: size, excerpt, truncated: size > 4096 },
+      log: { path, bytes: size, excerpt, truncated: size > limit },
       browserVerified: false, note: "Fresh check result only; later edits invalidate it. Compiler success is not browser or accessibility proof.",
     }
   } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-kudzu",
-  "version": "0.1.157",
+  "version": "0.1.159",
   "description": "Create a Kudzu project",
   "type": "module",
   "license": "MIT",