@agent-native/core 0.90.10 → 0.91.0

package/dist/vite/client.js

@@ -3,6 +3,7 @@ import fs from "fs";
 import { createRequire, syncBuiltinESMExports } from "module";
 import path from "path";
 import { fileURLToPath } from "url";
+import { mergePendingChangelog, parsePendingEntry, } from "../changelog/parse.js";
 import { getViteDevRecoveryScript } from "../client/vite-dev-recovery-script.js";
 import { findWorkspaceRoot } from "../scripts/utils.js";
 import { verifyEmbedSessionToken } from "../server/embed-session.js";
@@ -255,9 +256,7 @@ function findWorkspaceCoreSync(startDir) {
     }
     return null;
 }
-function findLocalWorkspacePackageDeps(startDir, workspaceRoot) {
-    if (!workspaceRoot)
-        return [];
+function findLocalWorkspacePackageDeps(startDir, _workspaceRoot) {
     const pkgPath = path.join(startDir, "package.json");
     if (!fs.existsSync(pkgPath))
         return [];
@@ -268,22 +267,25 @@ function findLocalWorkspacePackageDeps(startDir, workspaceRoot) {
             ...(pkg.devDependencies ?? {}),
             ...(pkg.peerDependencies ?? {}),
         };
-        const req = createRequire(pkgPath);
         const seen = new Set();
         const packages = [];
         for (const [packageName, range] of Object.entries(deps)) {
-            if (!range.startsWith("workspace:"))
-                continue;
             if (seen.has(packageName))
                 continue;
             seen.add(packageName);
             try {
-                const packageJsonPath = findInstalledPackageJsonPath(pkgPath, packageName) ??
-                    findPackageJsonFromEntry(req.resolve(packageName));
+                let packageJsonPath = null;
+                if (range.startsWith("file:")) {
+                    packageJsonPath = findFilePackageJsonPath(pkgPath, range);
+                }
+                else {
+                    continue;
+                }
                 if (!packageJsonPath)
                     continue;
                 const packageDir = fs.realpathSync(path.dirname(packageJsonPath));
-                if (!packageDir.startsWith(path.join(workspaceRoot, "packages")))
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+                if (packageJson?.name !== packageName)
                     continue;
                 packages.push({ packageName, packageDir });
             }
@@ -297,24 +299,13 @@ function findLocalWorkspacePackageDeps(startDir, workspaceRoot) {
         return [];
     }
 }
-function findInstalledPackageJsonPath(pkgPath, packageName) {
-    const candidate = path.join(path.dirname(pkgPath), "node_modules", ...packageName.split("/"), "package.json");
-    return fs.existsSync(candidate) ? candidate : null;
-}
-function findPackageJsonFromEntry(entryPath) {
-    let dir = fs.statSync(entryPath).isDirectory()
-        ? entryPath
-        : path.dirname(entryPath);
-    for (let i = 0; i < 20; i++) {
-        const candidate = path.join(dir, "package.json");
-        if (fs.existsSync(candidate))
-            return candidate;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
+function findFilePackageJsonPath(pkgPath, range) {
+    const spec = range.slice("file:".length);
+    const packageDir = spec.startsWith("//")
+        ? fileURLToPath(range)
+        : path.resolve(path.dirname(pkgPath), spec);
+    const packageJsonPath = path.join(packageDir, "package.json");
+    return fs.existsSync(packageJsonPath) ? packageJsonPath : null;
 }
 function findPnpmWorkspaceRoot(startDir) {
     let dir = path.resolve(startDir);
@@ -524,6 +515,17 @@ const CORE_CLIENT_SUBPATHS = [
     "@agent-native/core/client/transcription/use-live-transcription",
     "@agent-native/core/voice",
 ];
+const TOOLKIT_CLIENT_SUBPATHS = [
+    "@agent-native/toolkit",
+    "@agent-native/toolkit/app-shell",
+    "@agent-native/toolkit/collab-ui",
+    "@agent-native/toolkit/hooks",
+    "@agent-native/toolkit/onboarding",
+    "@agent-native/toolkit/provider",
+    "@agent-native/toolkit/sharing",
+    "@agent-native/toolkit/ui",
+    "@agent-native/toolkit/utils",
+];
 const NODE_SSR_NATIVE_EXTERNALS = ["better-sqlite3", "bindings"];
 function getDefaultOptimizeDeps(cwd) {
     const inMonorepo = findCoreSrcDir(cwd) !== null;
@@ -581,6 +583,10 @@ function getDefaultOptimizeDeps(cwd) {
                     specifier: "@agent-native/core/client/tools",
                     packageName: "@agent-native/core",
                 },
+                ...TOOLKIT_CLIENT_SUBPATHS.map((specifier) => ({
+                    specifier,
+                    packageName: "@agent-native/toolkit",
+                })),
             ]),
         { specifier: "@libsql/client" },
         { specifier: "@amplitude/analytics-browser" },
@@ -1471,6 +1477,119 @@ function ssrStubPlugin(packages) {
         },
     };
 }
+function splitViteRequest(id) {
+    const queryIndex = id.indexOf("?");
+    if (queryIndex === -1)
+        return null;
+    return {
+        file: id.slice(0, queryIndex),
+        query: id.slice(queryIndex + 1),
+    };
+}
+function hasRawQuery(query) {
+    return new URLSearchParams(query).has("raw");
+}
+function normalizeViteFilePath(file) {
+    if (!file || file.startsWith("\0"))
+        return null;
+    const fsPath = file.startsWith("/@fs/") ? file.slice("/@fs".length) : file;
+    try {
+        return decodeURI(fsPath);
+    }
+    catch {
+        return fsPath;
+    }
+}
+function changelogRawPathFromId(id) {
+    const request = splitViteRequest(id);
+    if (!request || !hasRawQuery(request.query))
+        return null;
+    const file = normalizeViteFilePath(request.file);
+    if (!file || path.basename(file) !== "CHANGELOG.md")
+        return null;
+    return path.resolve(file);
+}
+function resolveChangelogRawImport(source, importer) {
+    const request = splitViteRequest(source);
+    if (!request || !hasRawQuery(request.query))
+        return null;
+    const rawFile = normalizeViteFilePath(request.file);
+    if (!rawFile || path.basename(rawFile) !== "CHANGELOG.md")
+        return null;
+    const rawImporter = importer?.split("?")[0];
+    const importerFile = (rawImporter && normalizeViteFilePath(rawImporter)) ||
+        rawImporter ||
+        path.join(process.cwd(), "index.ts");
+    const resolved = path.isAbsolute(rawFile)
+        ? rawFile
+        : path.resolve(path.dirname(importerFile), rawFile);
+    return `${resolved}?${request.query}`;
+}
+function readAppChangelogMarkdown(changelogPath, watchFile) {
+    // Only ever register real files with Vite's `addWatchFile`. Passing a
+    // directory makes import-analysis try to resolve it as a module and fail
+    // with "Failed to resolve import .../changelog", which breaks hydration for
+    // every template in dev. New/removed pending files are still picked up via
+    // `handleHotUpdate` (Vite watches the project root recursively).
+    watchFile(changelogPath);
+    const existing = fs.existsSync(changelogPath)
+        ? fs.readFileSync(changelogPath, "utf-8")
+        : "";
+    const pendingDir = path.join(path.dirname(changelogPath), "changelog");
+    if (!fs.existsSync(pendingDir)) {
+        return existing;
+    }
+    const pending = fs
+        .readdirSync(pendingDir)
+        .filter((file) => file.endsWith(".md") && file.toLowerCase() !== "readme.md")
+        .sort()
+        .map((file) => {
+        const filePath = path.join(pendingDir, file);
+        watchFile(filePath);
+        return parsePendingEntry(fs.readFileSync(filePath, "utf-8"));
+    });
+    return mergePendingChangelog(existing, pending);
+}
+function isChangelogSourceFile(file) {
+    if (path.basename(file) === "CHANGELOG.md")
+        return true;
+    return (path.basename(path.dirname(file)) === "changelog" &&
+        file.endsWith(".md") &&
+        path.basename(file).toLowerCase() !== "readme.md");
+}
+function invalidateChangelogRawModules(server) {
+    const moduleGraph = server.moduleGraph;
+    if (!moduleGraph?.idToModuleMap || !moduleGraph.invalidateModule)
+        return;
+    for (const mod of moduleGraph.idToModuleMap.values()) {
+        if (!mod?.id || !changelogRawPathFromId(mod.id))
+            continue;
+        moduleGraph.invalidateModule(mod);
+    }
+}
+function appChangelogRawPlugin() {
+    return {
+        name: "agent-native-app-changelog-raw",
+        enforce: "pre",
+        resolveId(source, importer) {
+            return resolveChangelogRawImport(source, importer);
+        },
+        load(id) {
+            const changelogPath = changelogRawPathFromId(id);
+            if (!changelogPath)
+                return null;
+            const markdown = readAppChangelogMarkdown(changelogPath, (file) => this.addWatchFile(file));
+            return `export default ${JSON.stringify(markdown)};`;
+        },
+        handleHotUpdate(ctx) {
+            if (!isChangelogSourceFile(ctx.file))
+                return;
+            invalidateChangelogRawModules(ctx.server);
+            ctx.server.ws.send({ type: "full-reload" });
+            return [];
+        },
+    };
+}
 /**
  * Expose the resolved Vite dev server port as process.env.PORT so that
  * in-process scripts (which use localFetch → http://localhost:${PORT}/api/...)
@@ -1659,12 +1778,13 @@ function localWorkspacePackageAliases(packages) {
             if (!exportsMap || typeof exportsMap !== "object")
                 continue;
             for (const [exportPath, target] of Object.entries(exportsMap)) {
-                if (typeof target !== "string")
+                const exportTarget = localWorkspaceExportTarget(packageDir, target);
+                if (!exportTarget)
                     continue;
                 const importPath = exportPath === "."
                     ? packageName
                     : `${packageName}${exportPath.slice(1)}`;
-                const replacement = path.resolve(packageDir, target);
+                const replacement = path.resolve(packageDir, exportTarget);
                 if (importPath.includes("*") || replacement.includes("*")) {
                     aliases.push({
                         find: new RegExp(`^${escapeRegex(importPath).replace("\\*", "(.+)")}$`),
@@ -1684,6 +1804,48 @@ function localWorkspacePackageAliases(packages) {
     }
     return aliases;
 }
+function localWorkspaceExportTarget(packageDir, target) {
+    const rawTarget = pickLocalWorkspaceExportTarget(target);
+    if (!rawTarget)
+        return null;
+    return distExportToSourceTarget(packageDir, rawTarget);
+}
+function pickLocalWorkspaceExportTarget(target) {
+    if (typeof target === "string")
+        return target;
+    if (!target || typeof target !== "object" || Array.isArray(target)) {
+        return null;
+    }
+    const record = target;
+    for (const condition of ["development", "browser", "import", "default"]) {
+        const resolved = pickLocalWorkspaceExportTarget(record[condition]);
+        if (resolved)
+            return resolved;
+    }
+    return null;
+}
+function distExportToSourceTarget(packageDir, target) {
+    if (!target.startsWith("./dist/"))
+        return target;
+    if (target.includes("*")) {
+        return target
+            .replace("./dist/", "./src/")
+            .replace(/\.d\.ts$/, "")
+            .replace(/\.js$/, "");
+    }
+    const sourceBase = target
+        .replace("./dist/", "./src/")
+        .replace(/\.d\.ts$/, "")
+        .replace(/\.js$/, "");
+    const candidates = target.endsWith(".css")
+        ? [sourceBase]
+        : [`${sourceBase}.tsx`, `${sourceBase}.ts`, sourceBase];
+    for (const candidate of candidates) {
+        if (fs.existsSync(path.resolve(packageDir, candidate)))
+            return candidate;
+    }
+    return target;
+}
 function aliasArrayFrom(alias) {
     if (!alias)
         return [];
@@ -1701,7 +1863,6 @@ const DEFAULT_VITE_WATCH_IGNORES = [
     "**/.generated/**",
     "**/.agents/**",
     "**/.claude/**",
-    "**/changelog/**",
     "**/data/**",
     "**/dist/**",
     "**/build/**",
@@ -1722,6 +1883,7 @@ function createAgentNativePlugins(options, { command, includeReactTransform, use
         // the server, so we can't blanket-stub it here).
         ssrStubPlugin(options.ssrStubs ?? []),
         ...userPlugins,
+        appChangelogRawPlugin(),
         actionTypesPlugin(),
         agentsBundlePlugin(),
         autoReloadOnOptimizeDep(),