@agent-native/core 0.207.1 → 0.207.2-nightly-20261013011333

package/dist/vite/motion-source-provenance-plugin.js

@@ -0,0 +1,339 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { parse } from "@babel/parser";
+import MagicString from "magic-string";
+import { parse as parseHtml } from "parse5";
+import { generatedMotionNodeId, isMotionSourceHostElementTag, } from "../shared/motion-source-node-id.js";
+const NODE_ID_ATTRIBUTE = "data-agent-native-node-id";
+const SOURCE_FILE_ATTRIBUTE = "data-agent-native-motion-source-file";
+const SOURCE_HASH_ATTRIBUTE = "data-agent-native-motion-source-hash";
+const HTML_NODE_ID_ATTRIBUTE = "data-agent-native-node-id";
+function escapeHtmlAttribute(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll('"', """)
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+function instrumentMotionHtmlProvenance(args) {
+    const parseErrors = [];
+    const document = parseHtml(args.html, {
+        sourceCodeLocationInfo: true,
+        onParseError(error) {
+            parseErrors.push(error);
+        },
+    });
+    if (parseErrors.length > 0)
+        return null;
+    const hostNodes = [];
+    const visit = (node) => {
+        if (node.tagName && isMotionSourceHostElementTag(node.tagName)) {
+            hostNodes.push({ node, ordinal: hostNodes.length });
+        }
+        for (const child of node.childNodes ?? [])
+            visit(child);
+    };
+    visit(document);
+    const nodeIds = hostNodes.map(({ node, ordinal }) => {
+        const matches = (node.attrs ?? []).filter((attribute) => attribute.name === HTML_NODE_ID_ATTRIBUTE);
+        if (matches.length > 1)
+            return null;
+        const authoredId = matches[0]?.value;
+        const nodeId = authoredId ?? generatedMotionNodeId(args.modulePath, ordinal);
+        return /^[A-Za-z0-9_-]+$/.test(nodeId) ? nodeId : null;
+    });
+    const counts = new Map();
+    for (const nodeId of nodeIds) {
+        if (nodeId)
+            counts.set(nodeId, (counts.get(nodeId) ?? 0) + 1);
+    }
+    const edits = [];
+    for (const [index, { node }] of hostNodes.entries()) {
+        const nodeId = nodeIds[index];
+        const tag = node.sourceCodeLocation?.startTag;
+        if (!nodeId || counts.get(nodeId) !== 1 || !tag)
+            continue;
+        const attrs = new Map((node.attrs ?? []).map((attribute) => [attribute.name, attribute.value]));
+        const values = [
+            [HTML_NODE_ID_ATTRIBUTE, nodeId],
+            [SOURCE_FILE_ATTRIBUTE, args.modulePath],
+            [SOURCE_HASH_ATTRIBUTE, args.moduleVersionHash],
+        ];
+        const additions = [];
+        for (const [name, value] of values) {
+            const existingValue = attrs.get(name);
+            if (existingValue === value)
+                continue;
+            const location = tag.attrs?.[name];
+            const attribute = `${name}="${escapeHtmlAttribute(value)}"`;
+            if (location) {
+                edits.push({
+                    start: location.startOffset,
+                    end: location.endOffset,
+                    text: attribute,
+                });
+            }
+            else {
+                if (name === HTML_NODE_ID_ATTRIBUTE &&
+                    node.attrs?.some((entry) => entry.name === HTML_NODE_ID_ATTRIBUTE)) {
+                    continue;
+                }
+                additions.push(attribute);
+            }
+        }
+        if (additions.length === 0)
+            continue;
+        const tagEnd = args.html[tag.endOffset - 2] === "/"
+            ? tag.endOffset - 2
+            : tag.endOffset - 1;
+        edits.push({ start: tagEnd, end: tagEnd, text: ` ${additions.join(" ")}` });
+    }
+    if (edits.length === 0)
+        return null;
+    const ordered = [...edits].sort((left, right) => right.start - left.start || right.end - left.end);
+    let result = args.html;
+    let previousStart = args.html.length + 1;
+    for (const edit of ordered) {
+        if (edit.end > previousStart || edit.end > args.html.length)
+            return null;
+        result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+        previousStart = edit.start;
+    }
+    return result;
+}
+/** Adds dev-only JSX identity evidence so source edits follow rendered nodes. */
+export function motionSourceProvenancePlugin() {
+    let root = process.cwd();
+    let command = "serve";
+    return {
+        name: "agent-native-motion-source-provenance",
+        enforce: "pre",
+        configResolved(config) {
+            root = path.resolve(config.root);
+            command = config.command;
+        },
+        transformIndexHtml: {
+            order: "pre",
+            handler(html, context) {
+                if (command !== "serve" || !context.filename)
+                    return;
+                const absolutePath = path.resolve(context.filename);
+                const modulePath = path
+                    .relative(root, absolutePath)
+                    .split(path.sep)
+                    .join("/");
+                const extension = path.extname(modulePath).toLowerCase();
+                if (!modulePath ||
+                    path.isAbsolute(modulePath) ||
+                    modulePath === ".." ||
+                    modulePath.startsWith("../") ||
+                    ![".html", ".htm"].includes(extension) ||
+                    modulePath
+                        .split("/")
+                        .some((segment) => ["node_modules", ".vite", "dist", "build"].includes(segment))) {
+                    return;
+                }
+                let diskSource;
+                try {
+                    diskSource = readFileSync(absolutePath, "utf8");
+                }
+                catch (error) {
+                    throw new Error(`Unable to read the Motion HTML source at ${absolutePath}.`, { cause: error });
+                }
+                if (diskSource !== html)
+                    return;
+                const moduleVersionHash = createHash("sha256")
+                    .update(diskSource)
+                    .digest("hex");
+                return (instrumentMotionHtmlProvenance({
+                    html,
+                    modulePath,
+                    moduleVersionHash,
+                }) ?? undefined);
+            },
+        },
+        transform(code, id) {
+            if (command !== "serve" || !id || id.startsWith("\0"))
+                return null;
+            const fileName = id.split("?", 1)[0];
+            const extension = path.extname(fileName).toLowerCase();
+            if (extension !== ".tsx" && extension !== ".jsx")
+                return null;
+            const absolutePath = path.resolve(fileName);
+            let diskSource;
+            try {
+                diskSource = readFileSync(absolutePath, "utf8");
+            }
+            catch (error) {
+                throw new Error(`Unable to read the Motion source module at ${absolutePath}.`, { cause: error });
+            }
+            if (diskSource !== code)
+                return null;
+            const modulePath = path
+                .relative(root, absolutePath)
+                .split(path.sep)
+                .join("/");
+            if (!modulePath ||
+                modulePath === ".." ||
+                modulePath.startsWith("../") ||
+                modulePath
+                    .split("/")
+                    .some((segment) => ["node_modules", ".vite", "dist", "build"].includes(segment))) {
+                return null;
+            }
+            if (!code.includes("<"))
+                return null;
+            let syntaxTree;
+            try {
+                syntaxTree = parse(code, {
+                    plugins: extension === ".tsx" ? ["jsx", "typescript"] : ["jsx"],
+                    sourceType: "unambiguous",
+                });
+            }
+            catch (error) {
+                if (error instanceof SyntaxError)
+                    return null;
+                throw error;
+            }
+            const sourceHash = createHash("sha256").update(diskSource).digest("hex");
+            const magic = new MagicString(code, { filename: absolutePath });
+            let hostElementOrdinal = 0;
+            let changed = false;
+            const visit = (node) => {
+                if (node.type === "JSXElement") {
+                    const opening = asBabelNode(node.openingElement);
+                    const tag = asBabelNode(opening?.name);
+                    if (opening?.type === "JSXOpeningElement" &&
+                        tag?.type === "JSXIdentifier" &&
+                        typeof tag.name === "string" &&
+                        isMotionSourceHostElementTag(tag.name)) {
+                        const ordinal = hostElementOrdinal++;
+                        const properties = Array.isArray(opening.attributes)
+                            ? opening.attributes
+                                .map(asBabelNode)
+                                .filter((property) => property !== null)
+                            : [];
+                        const hasSpread = properties.some((property) => property.type === "JSXSpreadAttribute");
+                        const attributes = new Map();
+                        for (const property of properties) {
+                            if (property.type !== "JSXAttribute")
+                                continue;
+                            const name = asBabelNode(property.name);
+                            if (name?.type !== "JSXIdentifier" ||
+                                typeof name.name !== "string") {
+                                continue;
+                            }
+                            const matching = attributes.get(name.name) ?? [];
+                            matching.push(property);
+                            attributes.set(name.name, matching);
+                        }
+                        const isStaticStringAttribute = (property) => {
+                            const value = asBabelNode(property.value);
+                            return (value?.type === "StringLiteral" &&
+                                typeof value.value === "string");
+                        };
+                        const staticStringValue = (property) => {
+                            const value = property ? asBabelNode(property.value) : null;
+                            return value?.type === "StringLiteral" &&
+                                typeof value.value === "string"
+                                ? value.value
+                                : undefined;
+                        };
+                        const idAttributes = attributes.get(NODE_ID_ATTRIBUTE) ?? [];
+                        const hasDynamicNodeId = idAttributes.length > 0 &&
+                            (idAttributes.length !== 1 ||
+                                !isStaticStringAttribute(idAttributes[0]));
+                        const authoredNodeId = idAttributes.length === 1 && !hasDynamicNodeId
+                            ? staticStringValue(idAttributes[0])
+                            : undefined;
+                        const nodeId = authoredNodeId ?? generatedMotionNodeId(modulePath, ordinal);
+                        const malformedReservedAttribute = [
+                            NODE_ID_ATTRIBUTE,
+                            SOURCE_FILE_ATTRIBUTE,
+                            SOURCE_HASH_ATTRIBUTE,
+                        ].some((name) => {
+                            const matches = attributes.get(name) ?? [];
+                            return (matches.length > 1 ||
+                                (matches.length === 1 && !isStaticStringAttribute(matches[0])));
+                        });
+                        if (!hasSpread &&
+                            !hasDynamicNodeId &&
+                            !malformedReservedAttribute &&
+                            /^[A-Za-z0-9_-]+$/.test(nodeId)) {
+                            const expectedAttributes = [
+                                ...(!authoredNodeId
+                                    ? [[NODE_ID_ATTRIBUTE, nodeId]]
+                                    : []),
+                                [SOURCE_FILE_ATTRIBUTE, modulePath],
+                                [SOURCE_HASH_ATTRIBUTE, sourceHash],
+                            ];
+                            for (const [name, value] of expectedAttributes) {
+                                const existing = attributes.get(name) ?? [];
+                                if (existing.length === 0) {
+                                    const insertionPoint = properties.at(-1)?.end ?? tag.end;
+                                    if (typeof insertionPoint !== "number") {
+                                        throw new Error(`Unable to locate JSX attributes in ${absolutePath}.`);
+                                    }
+                                    magic.appendLeft(insertionPoint, ` ${name}=${JSON.stringify(value)}`);
+                                    changed = true;
+                                    continue;
+                                }
+                                const attribute = existing[0];
+                                const start = attribute.start;
+                                const end = attribute.end;
+                                if (existing.length !== 1 ||
+                                    !isStaticStringAttribute(attribute) ||
+                                    typeof start !== "number" ||
+                                    typeof end !== "number") {
+                                    continue;
+                                }
+                                if (staticStringValue(attribute) !== value) {
+                                    magic.update(start, end, `${name}=${JSON.stringify(value)}`);
+                                    changed = true;
+                                }
+                            }
+                        }
+                    }
+                }
+                for (const value of Object.values(node)) {
+                    if (Array.isArray(value)) {
+                        for (const child of value) {
+                            const astChild = asBabelNode(child);
+                            if (astChild)
+                                visit(astChild);
+                        }
+                    }
+                    else {
+                        const astChild = asBabelNode(value);
+                        if (astChild)
+                            visit(astChild);
+                    }
+                }
+            };
+            const program = asBabelNode(syntaxTree.program);
+            if (!program)
+                return null;
+            visit(program);
+            if (!changed)
+                return null;
+            return {
+                code: magic.toString(),
+                map: magic.generateMap({
+                    hires: "boundary",
+                    includeContent: true,
+                    source: modulePath,
+                }),
+            };
+        },
+    };
+}
+function asBabelNode(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        !("type" in value) ||
+        typeof value.type !== "string") {
+        return null;
+    }
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.207.1",
+  "version": "0.207.2-nightly-20261013011333",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -109,6 +109,7 @@
     "./server/interval-job": "./dist/server/interval-job.js",
     "./server/sse": "./dist/server/sse.js",
     "./server/short-lived-token": "./dist/server/short-lived-token.js",
+    "./visual-edit-bridge-capability": "./dist/server/visual-edit-bridge-capability.js",
     "./integrations": "./dist/integrations/index.js",
     "./integrations/computer-supervision": "./dist/integrations/computer-supervision.js",
     "./integrations/runtime": "./dist/integrations/runtime.js",
@@ -523,6 +524,8 @@
     "./client/integrations/webhook-url": "./dist/client/integrations/webhook-url.js",
     "./client/labs/use-lab": "./dist/client/labs/use-lab.js",
     "./client/mcp-app-host": "./dist/client/mcp-app-host.js",
+    "./client/motion-text": "./dist/client/motion-text.js",
+    "./client/motion-text.css": "./dist/client/motion-text.css",
     "./client/onboarding/first-run-enabled": "./dist/client/onboarding/first-run-enabled.js",
     "./client/onboarding/first-run-registry": "./dist/client/onboarding/first-run-registry.js",
     "./client/onboarding/first-run-status": "./dist/client/onboarding/first-run-status.js",
@@ -609,6 +612,8 @@
     "./shared/loading-labels": "./dist/shared/loading-labels.js",
     "./shared/mcp-app-widget-embed": "./dist/shared/mcp-app-widget-embed.js",
     "./shared/mcp-connect-content": "./dist/shared/mcp-connect-content.js",
+    "./shared/motion-easing": "./dist/shared/motion-easing.js",
+    "./shared/motion-source-node-id": "./dist/shared/motion-source-node-id.js",
     "./shared/password-policy": "./dist/shared/password-policy.js",
     "./shared/qa-test-email": "./dist/shared/qa-test-email.js",
     "./shared/runtime-config": "./dist/shared/runtime-config.js",
@@ -653,6 +658,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.90.0",
+    "@babel/parser": "8.0.7",
     "@clack/prompts": "^1.7.0",
     "@mcp-b/webmcp-polyfill": "^5.1.0",
     "@modelcontextprotocol/client": "2.0.0",
@@ -681,8 +687,10 @@
     "jiti": "^2.7.0",
     "jose": "^6.2.2",
     "linkedom": "^0.18.13",
+    "magic-string": "^1.4.3",
     "minimatch": "^10.0.0",
     "nitro": "3.0.260903-beta",
+    "parse5": "8.0.1",
     "postgres": "^3.4.9",
     "react-i18next": "17.0.8",
     "run": "2.0.1",
@@ -694,8 +702,8 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.207.1",
-    "@agent-native/recap-cli": "^0.5.70"
+    "@agent-native/recap-cli": "^0.5.70",
+    "@agent-native/agentkit": "^0.207.2-nightly-20261013011333"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",
@@ -765,7 +773,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": ">=0.196.0",
+    "@agent-native/core-corpus": "0.207.2-nightly-20261013011333",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",
@@ -951,6 +959,7 @@
     "build": "tsc && tsc -p tsconfig.cli.json && node scripts/finalize-build.mjs && node scripts/check-dist-imports.mjs",
     "dev": "tsc --watch",
     "typecheck": "tsc --noEmit",
-    "test": "vitest --run --dir src"
+    "test": "vitest --run --dir src",
+    "test:motion-text-package": "vitest --run scripts/motion-text-package.spec.ts"
   }
 }

package/src/templates/factory/.agents/skills/review-latest-feedback/SKILL.md

@@ -19,7 +19,7 @@ Four phases, in order. Phase 0 comes before any investigation, not after.
    before investigating any of it.
 1. **Answer the people who answered you.** Older open questions first.
 2. **Fix** what the evidence actually proves, at the owning boundary.
-3. **Reply**, under a hard question budget, then recap.
+3. **Reply** with useful questions, then recap.
 
 Output is fixes. Reply in-thread for every workflow reaction added this run;
 continuing work gets a concrete progress reply, and resolved work gets a final
@@ -82,9 +82,13 @@ error message, URL, or visible flow is enough to start tracing its owner; don't
 wait for details that would not change the reproduction attempt. Phase 2's
 local reproduction procedure applies to all defect reports, not only bashes.
 
-If no safe repo-owned fix is evident after that attempt, record the specific
-evidence limit. Ask only a question whose answer could change the reproduction
-or unblock a fix; after four days without an answer, record **Abandoned - no
+If no safe repo-owned fix is evident after reproduction, record the evidence
+limit. For each defect where reporter input changes reproduction or unblocks a
+fix, ask one direct question naming the missing detail or action and why it
+gates the next step. Inspect supplied run IDs, logs, links, and artifacts
+yourself. Keep internal access, config, observability, and deployment gaps
+internal; never ask reporters for developer traces. Do not label the thread
+**Open** instead of asking. After four days unanswered, record **Abandoned - no
 answer in 4 days**.
 
 Use **Skipped** only for non-defects, never breakage. **Open - no question**
@@ -448,9 +452,11 @@ instruction or prompt exception.
 
 ## Phase 3: reply
 
-Thank issue reporters for opening it and Slack reporters for sharing. Give the
-status or ask a useful question. Follow `address-feedback-with-replies` for
-Slack voice. End each Slack reply with `this was sent from a bot.` after its
+Thank issue reporters for opening it and Slack reporters for sharing. Give an
+active status while work continues. If reporter input gates a fix, ask the
+direct question specified in Phase 0; do not substitute **Open**, **pending**,
+or an evidence description. Follow `address-feedback-with-replies` for Slack
+voice. End each Slack reply with `this was sent from a bot.` after its
 plain-language status.
 
 Short replies: say the change, limits, and next step. Link merged PRs and say
@@ -474,32 +480,26 @@ needed. Do not reopen Slack in later runs to reply.
   observations may be silent; merged Slack fixes still get the reply above.
   **Shipped** is for upvoted improvements.
 - **In progress** — name continuing work and its owner; ask nothing.
-- **A question** — subject to the budget below.
+- **A question** — follow the rules below.
 
-Unclaimed scope/noise gets an internal recap row. Ask about an unverified defect
-only when one answer would unblock it; otherwise record **Open - no question**
-once. Cluster duplicates. Before re-reading any thread to reply, apply the Slack
-ownership gate; stay out of marked messages and active human work.
+Unclaimed scope/noise gets an internal recap row. Cluster duplicates. Before
+replying, apply the Slack ownership gate; stay out of marked messages and active
+human work.
 
-### The question budget
+### Ask only answerable questions
 
-**At most three questions per run, across all sources.** Most runs ask zero or
-one.
+Ask one direct question for each distinct blocked defect when the reporter's
+answer or action changes reproduction or unblocks the fix. There is no per-run
+cap; do not replace a useful question with **Open** or an in-progress status.
+Keep one pending question per thread. After an answer, try the fix before asking
+anything else. Never ask for supplied logs/IDs, internal access/config/tooling,
+subjective choices, or details that do not change the next step. If a
+user-visible link or ID alone blocks reproduction, ask for it and say where to
+find it.
 
-So rank before you ask. For each candidate, state: *if I get this answer, I
-can ship the fix.* Ask the three with the strongest answer. If fewer than
-three clear that bar, ask fewer. Everything below the cut is an internal open
-item, not a message.
-
-Never ask for supplied/inspectable evidence, irrelevant IDs/build numbers,
-subjective choices, or internal blockers. If a user-visible link or ID is the
-sole blocker, ask plainly and say where to find it.
-
-At most one clarification question may be pending per thread at a time. Once it
-is answered or resolved, attempt the fix; if that exposes a different required
-detail, ask at most one new, non-repeating question. Never stack questions or
-repeat a pending one. If a needed artifact is inaccessible to you, ask for a
-fresh link - not for its contents again.
+If an answer exposes a different required detail, ask at most one new,
+non-repeating question. If an artifact is inaccessible, request a fresh link,
+not its contents.
 
 ## Verification and identity
 
@@ -563,7 +563,7 @@ Messages: product N · QA N · dev N (total N)
 Deployment cursor: <timestamp> · carried active run IDs/rows: <ids/count>
 Release lanes: N inspected · failed/stale N · target verified N
 Reaction-gated skips: N · claimed N · answered N
-Questions asked: N/3 · Dropped at 4 days: N
+Questions asked: N · Dropped at 4 days: N
 Repeats of a prior Fixed claim: N (each with its earlier thread and failed fix)
 Upvoted items in scope: N (built: N)
 
@@ -576,12 +576,11 @@ Tracker: <sheet/export and bounded range> - N rows enumerated, N ledgers complet
 Unavailable or unverified: ...
 ```
 
-`Open - no question` is a last resort, not a success state. It requires that
-you worked the defect, could not fix it, and could not form a question that would
-unblock it; a run whose ledger is mostly `Open - no question` has under-asked, not
-finished. It keeps our eye and has no checkmark. "Nothing
-matched" is valid only after each source was queried successfully, with the
-cursor stated.
+`Open - no question` follows reproduction when there is no safe fix and no
+reporter answer or action that changes the next step. Ask when reporter input
+unblocks the fix; keep internal access/tooling blockers internal. Mostly open
+ledgers mean under-asking. Keep `👀`, no `✅`. "Nothing matched" is valid only
+after every source was queried successfully and the cursor is stated.
 
 ## Related skills