create-kudzu 0.1.156 → 0.1.158

package/README.md

@@ -10,13 +10,13 @@ cd my-app
 npm run dev
 ```
 
-The generated project is a working showcase on `@kudzujs/core@^0.16.34` with reusable components, an interactive state example, a zero-JavaScript static route, page metadata, responsive CSS, and `npm run check`. Configuration remains optional until the app needs custom assets, document defaults, navigation, or build hooks.
+The generated project is a working showcase on `@kudzujs/core@^0.16.36` with reusable components, an interactive state example, a zero-JavaScript static route, page metadata, responsive CSS, and `npm run check`. Configuration remains optional until the app needs custom assets, document defaults, navigation, or build hooks.
 
 Use `--no-install` to create the files without installing dependencies.
 
 ## Optional AI authoring guidance
 
-`create-kudzu@0.1.156` adds optional local AI developer tools:
+`create-kudzu@0.1.158` provides optional local AI developer tools with managed check cancellation:
 
 ```bash
 npm create kudzu@latest my-app -- --ai
@@ -53,10 +53,16 @@ npm run ai -- check --timeout-ms 600000
   log excerpt. Failure stays nonzero. The default timeout is five minutes; choose
   an integer from 1 to 1,200,000 ms. Timeout/cancellation terminates the spawned
   process group on Unix or process tree on Windows and reports failure.
+  Under the existing `KUDZU_AI_DELIVERY_GROUP=1` managed-runner contract, Unix
+  checks inherit their outer group so a hard group cancellation also reaches
+  their ordinary descendants. A check-local timeout or interruption uses native
+  `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

@@ -41,20 +41,34 @@ export async function check(root, timeoutMs = 300000) {
   const directory = await mkdtemp(join(logs, "check-")), path = join(directory, "output.log")
   const log = await open(path, "wx+")
   const start = performance.now()
+  const managed = process.env.KUDZU_AI_DELIVERY_GROUP === "1"
   try {
     const result = await new Promise(resolveRun => {
       const child = spawn(process.platform === "win32" ? "npm.cmd" : "npm", ["run", "check"], {
-        cwd: root, detached: process.platform !== "win32", shell: process.platform === "win32",
+        cwd: root, detached: process.platform !== "win32" && !managed, shell: process.platform === "win32",
         stdio: ["ignore", log.fd, log.fd], env: { ...process.env, FORCE_COLOR: "0", KUDZU_AI_CHECK_ROOT: root },
       })
       let timedOut = false, interrupted = null, error = null
       const terminate = () => {
-        if (!child.pid) return
+        if (!child.pid || child.exitCode !== null || child.signalCode !== null) return
         if (process.platform === "win32") {
           const killed = spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { encoding: "utf8" })
           if (killed.status !== 0) error = killed.error?.message ?? killed.stderr ?? "Could not terminate check tree"
         } else {
-          try { process.kill(-child.pid, "SIGKILL") } catch (failure) { if (failure.code !== "ESRCH") error = failure.message }
+          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 })
+            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))
+              if (parents.some(row => row.length !== 2 || row.some(id => !Number.isSafeInteger(id) || id < 0))) error = "Invalid managed check process table"
+              else for (let index = 0; index < pids.length; index++) for (const [pid, parent] of parents) {
+                if (parent === pids[index] && pid > 1 && pid !== process.pid && !pids.includes(pid)) pids.push(pid)
+              }
+            }
+          }
+          for (const pid of pids.reverse()) try { process.kill(pid, "SIGKILL") } catch (failure) { if (failure.code !== "ESRCH") error = failure.message }
         }
       }
       const onInterrupt = signal => { interrupted = signal; terminate() }
@@ -71,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/index.mjs

@@ -34,7 +34,7 @@ const files = {
       check: "tsc --noEmit && kudzu build"
     },
     dependencies: {
-      "@kudzujs/core": "^0.16.34"
+      "@kudzujs/core": "^0.16.36"
     },
     devDependencies: {
       typescript: "^5.9.2"

package/package.json

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