@agent-native/core 0.80.2 → 0.80.5

package/dist/cli/plan-local.js

@@ -711,10 +711,16 @@ function lintColumnsBlocks(file, source, issues) {
         const openingEnd = findJsxOpeningTagEnd(scanSource, start);
         if (openingEnd < 0)
             continue;
-        const opening = scanSource.slice(start, openingEnd + 1);
-        if (/\bcolumns\s*=/.test(opening)) {
-            addValidationIssue(issues, file, source, start, 'Columns must use <Column> children, not a columns= prop. Use <Columns><Column label="Before">...</Column><Column label="After">...</Column></Columns>.');
-        }
+        const opening = source.slice(start, openingEnd + 1);
+        const columnsAttr = readJsxAttribute(opening, "columns");
+        if (!columnsAttr)
+            continue;
+        const entries = columnsAttr.kind === "expression"
+            ? extractTopLevelObjectLiterals(columnsAttr.value)
+            : null;
+        if (entries && entries.length > 0)
+            continue;
+        addValidationIssue(issues, file, source, start, 'Columns must use <Column> children or a columns={[{ id, label, blocks }]} array, not a bare columns= prop. Use <Columns><Column label="Before">...</Column><Column label="After">...</Column></Columns>.');
     }
 }
 function findBalancedEnd(source, start, open, close) {
@@ -983,6 +989,56 @@ function hasRequiredEnumLiteral(objectSource, name, allowed) {
         return false;
     return allowed.includes(trimmed.slice(1, -1).trim());
 }
+// Shared per-item checks so the top-level `<Checklist items={[…]} />` tag and
+// blocks authored as JSON inside a container's `tabs={[…]}` / `columns={[…]}`
+// array enforce the SAME required fields. `listBase` is the absolute offset of
+// the items array in the original source so line numbers point near the item.
+function checkChecklistItemList(items, listBase, file, source, issues) {
+    items.forEach((item, index) => {
+        const base = listBase + item.start;
+        if (!hasRequiredStaticId(item.source)) {
+            addValidationIssue(issues, file, source, base, `Checklist items[${index}].id is required by the Plan renderer schema; add a stable string id.`);
+        }
+        if (!hasRequiredStaticString(item.source, "label")) {
+            addValidationIssue(issues, file, source, base, `Checklist items[${index}].label is required by the Plan renderer schema; add a non-empty string label.`);
+        }
+    });
+}
+function checkQuestionObjectList(questionObjects, listBase, tag, file, source, issues) {
+    questionObjects.forEach((question, questionIndex) => {
+        const questionBase = listBase + question.start;
+        if (!hasRequiredStaticId(question.source)) {
+            addValidationIssue(issues, file, source, questionBase, `${tag} questions[${questionIndex}].id is required by the Plan renderer schema; add a stable string id.`);
+        }
+        if (!hasRequiredStaticString(question.source, "title")) {
+            addValidationIssue(issues, file, source, questionBase, `${tag} questions[${questionIndex}].title is required by the Plan renderer schema; add a non-empty string title.`);
+        }
+        if (!hasRequiredEnumLiteral(question.source, "mode", [
+            "single",
+            "multi",
+            "freeform",
+        ])) {
+            addValidationIssue(issues, file, source, questionBase, `${tag} questions[${questionIndex}].mode is required by the Plan renderer schema; use "single", "multi", or "freeform".`);
+        }
+        const options = readTopLevelObjectProperty(question.source, "options");
+        if (!options)
+            return;
+        const optionObjects = extractTopLevelObjectLiterals(options.value);
+        if (!optionObjects) {
+            addValidationIssue(issues, file, source, questionBase + options.valueStart, `${tag} questions[${questionIndex}].options must be an inline array of object literals.`);
+            return;
+        }
+        optionObjects.forEach((option, optionIndex) => {
+            const optionBase = questionBase + options.valueStart + option.start;
+            if (!hasRequiredStaticId(option.source)) {
+                addValidationIssue(issues, file, source, optionBase, `${tag} questions[${questionIndex}].options[${optionIndex}].id is required by the Plan renderer schema; add a stable string id.`);
+            }
+            if (!hasRequiredStaticString(option.source, "label")) {
+                addValidationIssue(issues, file, source, optionBase, `${tag} questions[${questionIndex}].options[${optionIndex}].label is required by the Plan renderer schema; add a non-empty string label.`);
+            }
+        });
+    });
+}
 function lintChecklistShape(file, source, issues) {
     const scanSource = maskCodeRegions(source);
     const re = /<Checklist\b/g;
@@ -1005,15 +1061,7 @@ function lintChecklistShape(file, source, issues) {
             addValidationIssue(issues, file, source, start + items.start, "Checklist items must be an inline array of object literals so local check can validate the renderer schema.");
             continue;
         }
-        objects.forEach((item, index) => {
-            const base = start + items.start + item.start;
-            if (!hasRequiredStaticId(item.source)) {
-                addValidationIssue(issues, file, source, base, `Checklist items[${index}].id is required by the Plan renderer schema; add a stable string id.`);
-            }
-            if (!hasRequiredStaticString(item.source, "label")) {
-                addValidationIssue(issues, file, source, base, `Checklist items[${index}].label is required by the Plan renderer schema; add a non-empty string label.`);
-            }
-        });
+        checkChecklistItemList(objects, start + items.start, file, source, issues);
     }
 }
 function lintQuestionFormShape(file, source, issues) {
@@ -1041,43 +1089,114 @@ function lintQuestionFormShape(file, source, issues) {
             addValidationIssue(issues, file, source, start + questions.start, `${tag} questions must be a non-empty inline array of object literals.`);
             continue;
         }
-        questionObjects.forEach((question, questionIndex) => {
-            const questionBase = start + questions.start + question.start;
-            if (!hasRequiredStaticId(question.source)) {
-                addValidationIssue(issues, file, source, questionBase, `${tag} questions[${questionIndex}].id is required by the Plan renderer schema; add a stable string id.`);
-            }
-            if (!hasRequiredStaticString(question.source, "title")) {
-                addValidationIssue(issues, file, source, questionBase, `${tag} questions[${questionIndex}].title is required by the Plan renderer schema; add a non-empty string title.`);
-            }
-            if (!hasRequiredEnumLiteral(question.source, "mode", [
-                "single",
-                "multi",
-                "freeform",
-            ])) {
-                addValidationIssue(issues, file, source, questionBase, `${tag} questions[${questionIndex}].mode is required by the Plan renderer schema; use "single", "multi", or "freeform".`);
-            }
-            const options = readTopLevelObjectProperty(question.source, "options");
-            if (!options)
-                return;
-            const optionObjects = extractTopLevelObjectLiterals(options.value);
-            if (!optionObjects) {
-                addValidationIssue(issues, file, source, start + questions.start + question.start + options.valueStart, `${tag} questions[${questionIndex}].options must be an inline array of object literals.`);
-                return;
+        checkQuestionObjectList(questionObjects, start + questions.start, tag, file, source, issues);
+    }
+}
+function staticStringLiteralValue(value) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    const quote = trimmed[0];
+    if (quote !== '"' && quote !== "'" && quote !== "`")
+        return undefined;
+    if (!trimmed.endsWith(quote) || trimmed.length < 2)
+        return undefined;
+    if (quote === "`" && /\$\{/.test(trimmed))
+        return undefined;
+    return trimmed.slice(1, -1);
+}
+// Container blocks authored with a JSON attribute array (`<TabsBlock tabs={[…]}
+// />`) carry their children as nested block objects, not top-level JSX tags, so
+// the tag-based linters above never inspect them — the exact "false green" the
+// renderer catches because it validates the whole parsed block tree. Walk those
+// nested `blocks: [...]` arrays and enforce the same per-block required fields,
+// recursing through nested containers. This is still a subset of the renderer
+// schema (which is why `verify` is the authority), but it closes the common
+// nested checklist / question-form / missing-id case offline.
+const NESTED_CONTAINER_TAGS = [
+    { tag: "TabsBlock", attr: "tabs" },
+    { tag: "Tabs", attr: "tabs" },
+    { tag: "Columns", attr: "columns" },
+];
+function lintNestedContainerEntry(entrySource, entryBase, file, source, issues) {
+    const blocksProp = readTopLevelObjectProperty(entrySource, "blocks");
+    if (!blocksProp)
+        return;
+    const blockObjects = extractTopLevelObjectLiterals(blocksProp.value);
+    if (!blockObjects)
+        return;
+    const blocksBase = entryBase + blocksProp.valueStart;
+    for (const block of blockObjects) {
+        lintNestedBlock(block.source, blocksBase + block.start, file, source, issues);
+    }
+}
+function lintNestedBlock(blockSource, blockBase, file, source, issues) {
+    const typeProp = readTopLevelObjectProperty(blockSource, "type");
+    const type = staticStringLiteralValue(typeProp?.value);
+    if (!hasRequiredStaticId(blockSource)) {
+        addValidationIssue(issues, file, source, blockBase, `Nested ${type ?? "block"} is missing a required string \`id\`; the Plan renderer schema validates every nested block.`);
+    }
+    const dataProp = readTopLevelObjectProperty(blockSource, "data");
+    if (!dataProp)
+        return;
+    const dataBase = blockBase + dataProp.valueStart;
+    if (type === "checklist") {
+        const itemsProp = readTopLevelObjectProperty(dataProp.value, "items");
+        if (!itemsProp)
+            return;
+        const items = extractTopLevelObjectLiterals(itemsProp.value);
+        if (items) {
+            checkChecklistItemList(items, dataBase + itemsProp.valueStart, file, source, issues);
+        }
+        return;
+    }
+    // visual-questions shares question-form's schema; lint both.
+    if (type === "question-form" || type === "visual-questions") {
+        const questionsProp = readTopLevelObjectProperty(dataProp.value, "questions");
+        if (!questionsProp)
+            return;
+        const questionObjects = extractTopLevelObjectLiterals(questionsProp.value);
+        if (questionObjects) {
+            checkQuestionObjectList(questionObjects, dataBase + questionsProp.valueStart, type, file, source, issues);
+        }
+        return;
+    }
+    if (type === "tabs" || type === "columns") {
+        const innerAttr = type === "tabs" ? "tabs" : "columns";
+        const innerProp = readTopLevelObjectProperty(dataProp.value, innerAttr);
+        if (!innerProp)
+            return;
+        const innerEntries = extractTopLevelObjectLiterals(innerProp.value);
+        if (!innerEntries)
+            return;
+        const innerBase = dataBase + innerProp.valueStart;
+        for (const entry of innerEntries) {
+            lintNestedContainerEntry(entry.source, innerBase + entry.start, file, source, issues);
+        }
+    }
+}
+function lintNestedContainerBlocks(file, source, issues) {
+    const scanSource = maskCodeRegions(source);
+    for (const { tag, attr } of NESTED_CONTAINER_TAGS) {
+        const re = new RegExp(`<${tag}\\b`, "g");
+        let match;
+        while ((match = re.exec(scanSource))) {
+            const start = match.index;
+            const openingEnd = findJsxOpeningTagEnd(scanSource, start);
+            if (openingEnd < 0)
+                continue;
+            const opening = source.slice(start, openingEnd + 1);
+            const attrValue = readJsxAttribute(opening, attr);
+            if (!attrValue || attrValue.kind !== "expression")
+                continue;
+            const entries = extractTopLevelObjectLiterals(attrValue.value);
+            if (!entries)
+                continue;
+            const entriesBase = start + attrValue.start;
+            for (const entry of entries) {
+                lintNestedContainerEntry(entry.source, entriesBase + entry.start, file, source, issues);
             }
-            optionObjects.forEach((option, optionIndex) => {
-                const optionBase = start +
-                    questions.start +
-                    question.start +
-                    options.valueStart +
-                    option.start;
-                if (!hasRequiredStaticId(option.source)) {
-                    addValidationIssue(issues, file, source, optionBase, `${tag} questions[${questionIndex}].options[${optionIndex}].id is required by the Plan renderer schema; add a stable string id.`);
-                }
-                if (!hasRequiredStaticString(option.source, "label")) {
-                    addValidationIssue(issues, file, source, optionBase, `${tag} questions[${questionIndex}].options[${optionIndex}].label is required by the Plan renderer schema; add a non-empty string label.`);
-                }
-            });
-        });
+        }
     }
 }
 // Blank out fenced code blocks and inline code spans (preserving newlines and
@@ -1098,6 +1217,7 @@ export function validateLocalPlanFiles(files) {
         lintColumnsBlocks(entry.file, source, issues);
         lintChecklistShape(entry.file, entry.source, issues);
         lintQuestionFormShape(entry.file, entry.source, issues);
+        lintNestedContainerBlocks(entry.file, entry.source, issues);
     }
     return issues;
 }
@@ -1247,7 +1367,8 @@ export function writeLocalPlanPreview(input) {
 function buildLocalPlanBridgePayload(input) {
     const dir = path.resolve(input.dir);
     const files = readLocalPlanFiles(dir);
-    assertLocalPlanFilesValid(files);
+    if (!input.skipSourceValidation)
+        assertLocalPlanFilesValid(files);
     const parsed = stripFrontmatter(files.planMdx);
     const kind = input.kind || normalizeKind(parsed.frontmatter.kind);
     const title = input.title ||
@@ -1317,6 +1438,7 @@ export async function startLocalPlanBridge(input) {
         kind: input.kind,
         title: input.title,
         brief: input.brief,
+        skipSourceValidation: input.skipSourceValidation,
     });
     const token = input.token || crypto.randomBytes(24).toString("base64url");
     const host = input.host || "127.0.0.1";
@@ -1345,6 +1467,7 @@ export async function startLocalPlanBridge(input) {
                 kind: input.kind,
                 title: input.title,
                 brief: input.brief,
+                skipSourceValidation: input.skipSourceValidation,
             }));
         }
         catch (error) {
@@ -1418,8 +1541,88 @@ function localPlanBridgeWarnings(input) {
     }
     return warnings;
 }
+const VALIDATE_LOCAL_PLAN_ACTION = "validate-local-plan-source";
+/**
+ * Ask the Plan app to validate the folder against its real renderer schema
+ * (`parsePlanMdxFolder` + `planContentSchema`) via the public, no-DB
+ * `validate-local-plan-source` action. This is what makes `verify`
+ * authoritative: the hand-rolled `check` lint can disagree with the renderer,
+ * but this runs the renderer's own parser. Degrades gracefully (`ran: false`)
+ * when the endpoint is unreachable or a Plan app predates the action, so an
+ * old deploy never turns into a hard failure.
+ */
+export async function fetchRendererValidation(input) {
+    const fetchFn = input.fetchFn ?? fetch;
+    const endpoint = planActionEndpoint(input.appUrl, VALIDATE_LOCAL_PLAN_ACTION);
+    try {
+        const response = await fetchActionWithTimeout(endpoint, {
+            method: "POST",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ mdx: localPlanMdxFolder(input.files) }),
+        }, fetchFn);
+        if (!response.ok) {
+            const detail = await response.text().catch(() => "");
+            return {
+                ran: false,
+                endpoint,
+                error: `${VALIDATE_LOCAL_PLAN_ACTION} failed ${response.status} ${response.statusText}: ${sanitizeHttpDetail(detail, 300)}`,
+            };
+        }
+        const json = (await response.json().catch(() => null));
+        const body = json && isRecord(json.result) ? json.result : (json ?? undefined);
+        if (!body || typeof body.valid !== "boolean") {
+            return {
+                ran: false,
+                endpoint,
+                error: `${VALIDATE_LOCAL_PLAN_ACTION} returned an unexpected payload.`,
+            };
+        }
+        const issues = Array.isArray(body.issues)
+            ? body.issues.filter(isRecord).map((issue) => ({
+                path: typeof issue.path === "string" ? issue.path : "",
+                message: typeof issue.message === "string" ? issue.message : "Invalid value",
+            }))
+            : [];
+        return { ran: true, endpoint, valid: body.valid, issues };
+    }
+    catch (err) {
+        return {
+            ran: false,
+            endpoint,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function rendererValidationWarnings(validation, offlineIssues) {
+    if (!validation.ran) {
+        const base = `Plan content was NOT validated against the renderer schema (${validation.error ?? "validate endpoint unavailable"}). Fell back to the offline lint. Run against a Plan app that exposes ${VALIDATE_LOCAL_PLAN_ACTION} (e.g. --app-url http://localhost:8096) for authoritative validation.`;
+        if (offlineIssues.length === 0)
+            return [base];
+        const preview = offlineIssues
+            .slice(0, 8)
+            .map((issue) => `${issue.file}:${issue.line} ${issue.message}`)
+            .join("; ");
+        const overflow = offlineIssues.length > 8 ? ` (+${offlineIssues.length - 8} more)` : "";
+        return [base, `Offline lint rejected this plan: ${preview}${overflow}`];
+    }
+    if (validation.valid)
+        return [];
+    const issues = validation.issues ?? [];
+    const preview = issues
+        .slice(0, 8)
+        .map((issue) => issue.path ? `${issue.path}: ${issue.message}` : issue.message)
+        .join("; ");
+    const overflow = issues.length > 8 ? ` (+${issues.length - 8} more)` : "";
+    return [
+        `Renderer schema rejected this plan — it will not render. ${preview}${overflow}`,
+    ];
+}
 export async function verifyLocalPlanBridge(input) {
     const fetchFn = input.fetchFn ?? fetch;
+    const files = readLocalPlanFiles(input.dir);
     const bridge = await startLocalPlanBridge({
         dir: input.dir,
         kind: input.kind,
@@ -1430,6 +1633,9 @@ export async function verifyLocalPlanBridge(input) {
         port: input.port,
         token: input.token,
         urlFile: input.urlFile,
+        // Don't let the weaker offline lint abort the bridge before the authoritative
+        // renderer check runs — verify reports the renderer's verdict, not the lint's.
+        skipSourceValidation: true,
     });
     try {
         const preflight = await fetchFn(bridge.result.bridgeUrl, {
@@ -1456,8 +1662,21 @@ export async function verifyLocalPlanBridge(input) {
         const preflightOk = preflight.status === 204 &&
             preflight.headers.get("access-control-allow-origin") === "*" &&
             preflight.headers.get("access-control-allow-private-network") === "true";
+        const validation = await fetchRendererValidation({
+            appUrl: bridge.result.appUrl,
+            files,
+            fetchFn,
+        });
+        // The renderer's verdict is authoritative and gates `ok`. When it could not
+        // run (old/unreachable Plan app), fall back to the offline lint as the
+        // content signal so verify still catches the common cases offline instead
+        // of silently passing unvalidated content.
+        const offlineIssues = validation.ran ? [] : validateLocalPlanFiles(files);
+        const contentOk = validation.ran
+            ? validation.valid === true
+            : offlineIssues.length === 0;
         return {
-            ok: bridgeOk && preflightOk,
+            ok: bridgeOk && preflightOk && contentOk,
             dir: bridge.result.dir,
             url: bridge.result.url,
             ...(bridge.result.urlFile ? { urlFile: bridge.result.urlFile } : {}),
@@ -1482,10 +1701,14 @@ export async function verifyLocalPlanBridge(input) {
                 ...(mdxFiles ? { mdxFiles } : {}),
                 ...(payload?.error ? { error: payload.error } : {}),
             },
-            warnings: localPlanBridgeWarnings({
-                appUrl: bridge.result.appUrl,
-                bridgeUrl: bridge.result.bridgeUrl,
-            }),
+            validation,
+            warnings: [
+                ...localPlanBridgeWarnings({
+                    appUrl: bridge.result.appUrl,
+                    bridgeUrl: bridge.result.bridgeUrl,
+                }),
+                ...rendererValidationWarnings(validation, offlineIssues),
+            ],
         };
     }
     finally {
@@ -1551,7 +1774,9 @@ function runCheck(args) {
     const result = {
         ok: true,
         noDb: true,
-        validation: "passed",
+        validation: "lint-passed",
+        validationScope: "offline-lint",
+        note: "Quick offline lint only — NOT the full Plan renderer schema. A green here does not guarantee the plan renders. Run `plan local verify` against a Plan app for authoritative validation before handing off.",
         dir: files.dir,
         title: parsed.frontmatter.title || firstHeading(parsed.body),
         kind: normalizeKind(parsed.frontmatter.kind),