@agent-native/core 0.128.2 → 0.128.3

package/src/cli/sync-builder-starter-manifest.ts

@@ -1,631 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  isMigrationManifestActive,
-  readMigrationManifest,
-} from "../package-lifecycle/migration-manifest.js";
-import { _postProcessStandalone } from "./create.js";
-import { runMigrationCodemods } from "./migration-codemod.js";
-
-export const STARTER_APP_NAME = "builder-agent-native-starter";
-export const CHAT_TEMPLATE = "chat";
-
-/** Toolchain files that must track templates/chat or typecheck/build drift. */
-export const STARTER_TOOLCHAIN_SYNC_PATHS = [
-  "react-router.config.ts",
-  "vite.config.ts",
-  "tsconfig.json",
-  "ssr-entry.ts",
-  "app/vite-env.d.ts",
-  "app/routes.ts",
-  "server/routes/[...page].get.ts",
-  // server/plugins/* are intentionally excluded: starter keeps its own
-  // systemPrompt and auth marketing copy; post-process only rewrites appId/title.
-  "server/middleware/auth.ts",
-  "components.json",
-  ".oxfmtrc.json",
-  "netlify.toml",
-] as const;
-
-export const STARTER_SOURCE_MIGRATION_PATHS = [
-  ":(glob)**/*.ts",
-  ":(glob)**/*.tsx",
-] as const;
-
-const STANDALONE_SNAPSHOT_EXCLUDED_TOP_LEVEL = new Set([
-  ".deploy-tmp",
-  ".env",
-  ".env.local",
-  ".generated",
-  ".netlify",
-  ".output",
-  ".react-router",
-  "build",
-  "data",
-  "dist",
-  "node_modules",
-]);
-
-export type StarterToolchainSyncPath =
-  (typeof STARTER_TOOLCHAIN_SYNC_PATHS)[number];
-
-type PackageJson = Record<string, unknown>;
-
-export type StandaloneChatSnapshot = {
-  cleanup: () => void;
-  dir: string;
-  packageJson: PackageJson;
-  pnpmWorkspaceYaml: string | null;
-  toolchainFiles: Map<StarterToolchainSyncPath, string>;
-};
-
-export function listStarterSyncPaths(): string[] {
-  return [
-    "package.json",
-    "pnpm-lock.yaml",
-    "pnpm-workspace.yaml",
-    ...STARTER_TOOLCHAIN_SYNC_PATHS,
-    ...STARTER_SOURCE_MIGRATION_PATHS,
-  ];
-}
-
-export function migrateStarterSources(options: {
-  starterDir: string;
-  repoRoot: string;
-  coreVersion: string | null;
-  write?: boolean;
-}): { changedPaths: string[]; warnings: string[] } {
-  const manifestPath = path.join(
-    options.repoRoot,
-    "packages/core/migration-manifest.json",
-  );
-  const manifest = readMigrationManifest(manifestPath);
-  if (!manifest) {
-    throw new Error(`Could not read migration manifest at ${manifestPath}.`);
-  }
-  if (!isMigrationManifestActive(manifest, options.coreVersion)) {
-    return { changedPaths: [], warnings: [] };
-  }
-
-  const result = runMigrationCodemods({
-    root: options.starterDir,
-    manifests: [manifest],
-    apply: options.write,
-    // Checked-in migration targets are validated by the manifest guard before
-    // this source sync runs; starter dependencies are installed afterward.
-    targetExists: () => true,
-  });
-
-  return {
-    changedPaths: [
-      ...new Set(
-        result.changes.map((change) =>
-          path.relative(options.starterDir, change.file),
-        ),
-      ),
-    ].sort(),
-    warnings: result.warnings,
-  };
-}
-
-export function resolveStarterCoreVersion(
-  starterPackageJson: PackageJson,
-  repoRoot: string,
-): string | null {
-  const dependencies = starterPackageJson.dependencies;
-  if (dependencies && typeof dependencies === "object") {
-    const declared = (dependencies as Record<string, unknown>)[
-      "@agent-native/core"
-    ];
-    if (typeof declared === "string") {
-      const version = declared.match(/\d+\.\d+\.\d+/)?.[0];
-      if (version) return version;
-    }
-  }
-
-  try {
-    const corePackageJson = JSON.parse(
-      fs.readFileSync(
-        path.join(repoRoot, "packages/core/package.json"),
-        "utf-8",
-      ),
-    ) as { version?: unknown };
-    return typeof corePackageJson.version === "string"
-      ? corePackageJson.version
-      : null;
-  } catch {
-    return null;
-  }
-}
-
-export function findAgentNativeRoot(startDir = process.cwd()): string {
-  let dir = path.resolve(startDir);
-  for (let i = 0; i < 12; i++) {
-    const chatPackageJson = path.join(
-      dir,
-      "templates",
-      CHAT_TEMPLATE,
-      "package.json",
-    );
-    if (fs.existsSync(chatPackageJson)) {
-      return dir;
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  throw new Error(
-    "Could not find agent-native repo root (expected templates/chat/package.json).",
-  );
-}
-
-export function collectStarterToolchainFiles(
-  canonicalDir: string,
-): Map<StarterToolchainSyncPath, string> {
-  const files = new Map<StarterToolchainSyncPath, string>();
-  for (const relativePath of STARTER_TOOLCHAIN_SYNC_PATHS) {
-    const absolutePath = path.join(canonicalDir, relativePath);
-    if (!fs.existsSync(absolutePath)) continue;
-    files.set(relativePath, fs.readFileSync(absolutePath, "utf-8"));
-  }
-  return files;
-}
-
-export function createStandaloneChatSnapshot(
-  repoRoot?: string,
-): StandaloneChatSnapshot {
-  const root = repoRoot ?? findAgentNativeRoot();
-  const chatTemplateDir = path.join(root, "templates", CHAT_TEMPLATE);
-  const tempDir = fs.mkdtempSync(
-    path.join(os.tmpdir(), "an-builder-starter-sync-"),
-  );
-
-  fs.cpSync(chatTemplateDir, tempDir, {
-    recursive: true,
-    filter: (source) =>
-      shouldCopyStandaloneSnapshotPath(source, chatTemplateDir),
-  });
-  _postProcessStandalone(STARTER_APP_NAME, tempDir, CHAT_TEMPLATE);
-
-  const packageJson = JSON.parse(
-    fs.readFileSync(path.join(tempDir, "package.json"), "utf-8"),
-  ) as PackageJson;
-
-  const workspacePath = path.join(tempDir, "pnpm-workspace.yaml");
-  const pnpmWorkspaceYaml = fs.existsSync(workspacePath)
-    ? fs.readFileSync(workspacePath, "utf-8")
-    : null;
-
-  return {
-    cleanup: () => {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    },
-    dir: tempDir,
-    packageJson,
-    pnpmWorkspaceYaml,
-    toolchainFiles: collectStarterToolchainFiles(tempDir),
-  };
-}
-
-function shouldCopyStandaloneSnapshotPath(
-  source: string,
-  root: string,
-): boolean {
-  const relative = path.relative(root, source);
-  if (!relative) return true;
-  const topLevel = relative.split(path.sep)[0];
-  return !STANDALONE_SNAPSHOT_EXCLUDED_TOP_LEVEL.has(topLevel);
-}
-
-export function generateStandaloneChatManifest(repoRoot?: string): {
-  packageJson: PackageJson;
-  pnpmWorkspaceYaml: string | null;
-} {
-  const snapshot = createStandaloneChatSnapshot(repoRoot);
-  try {
-    return {
-      packageJson: snapshot.packageJson,
-      pnpmWorkspaceYaml: snapshot.pnpmWorkspaceYaml,
-    };
-  } finally {
-    snapshot.cleanup();
-  }
-}
-
-function mergePackageJsonRecords(
-  canonical: Record<string, string> | undefined,
-  starter: Record<string, string> | undefined,
-  starterPinnedKeys: string[] = [],
-): Record<string, string> {
-  const merged = { ...(canonical ?? {}) };
-  for (const [key, value] of Object.entries(starter ?? {})) {
-    if (!(key in merged)) {
-      merged[key] = value;
-    }
-  }
-  for (const key of starterPinnedKeys) {
-    const pinned = starter?.[key];
-    if (pinned) {
-      merged[key] = pinned;
-    }
-  }
-  return merged;
-}
-
-export function mergeStarterManifest(
-  starterPackageJson: PackageJson,
-  canonicalPackageJson: PackageJson,
-): PackageJson {
-  const merged = structuredClone(canonicalPackageJson) as PackageJson;
-
-  merged.name = starterPackageJson.name ?? STARTER_APP_NAME;
-  if (typeof starterPackageJson.displayName === "string") {
-    merged.displayName = starterPackageJson.displayName;
-  }
-  if (typeof starterPackageJson.description === "string") {
-    merged.description = starterPackageJson.description;
-  }
-  if (starterPackageJson.private !== undefined) {
-    merged.private = starterPackageJson.private;
-  }
-  if (typeof starterPackageJson.packageManager === "string") {
-    merged.packageManager = starterPackageJson.packageManager;
-  }
-
-  merged.dependencies = mergePackageJsonRecords(
-    canonicalPackageJson.dependencies as Record<string, string> | undefined,
-    starterPackageJson.dependencies as Record<string, string> | undefined,
-    ["@agent-native/core", "@agent-native/toolkit"],
-  );
-  merged.devDependencies = mergePackageJsonRecords(
-    canonicalPackageJson.devDependencies as Record<string, string> | undefined,
-    starterPackageJson.devDependencies as Record<string, string> | undefined,
-  );
-  merged.scripts = mergePackageJsonRecords(
-    canonicalPackageJson.scripts as Record<string, string> | undefined,
-    starterPackageJson.scripts as Record<string, string> | undefined,
-  );
-
-  return merged;
-}
-
-export function workspaceFileSyncChanged(
-  existingWorkspace: string | null,
-  canonicalWorkspace: string | null,
-): boolean {
-  if (canonicalWorkspace === null) {
-    return existingWorkspace !== null;
-  }
-  return existingWorkspace !== canonicalWorkspace;
-}
-
-export function applyWorkspaceFileSync(
-  targetPath: string,
-  canonicalWorkspace: string | null,
-): void {
-  if (canonicalWorkspace === null) {
-    if (fs.existsSync(targetPath)) {
-      fs.unlinkSync(targetPath);
-    }
-    return;
-  }
-  fs.writeFileSync(targetPath, canonicalWorkspace);
-}
-
-function stableJson(value: unknown): string {
-  return `${JSON.stringify(value, null, 2)}\n`;
-}
-
-export type StarterToolchainSyncChange = {
-  relativePath: StarterToolchainSyncPath;
-  changed: boolean;
-};
-
-export function diffStarterToolchainFiles(
-  starterDir: string,
-  canonicalFiles: Map<StarterToolchainSyncPath, string>,
-): StarterToolchainSyncChange[] {
-  return STARTER_TOOLCHAIN_SYNC_PATHS.map((relativePath) => {
-    const canonicalContent = canonicalFiles.get(relativePath) ?? null;
-    const targetPath = path.join(starterDir, relativePath);
-    const existingContent = fs.existsSync(targetPath)
-      ? fs.readFileSync(targetPath, "utf-8")
-      : null;
-    return {
-      relativePath,
-      changed: existingContent !== canonicalContent,
-    };
-  });
-}
-
-export function applyStarterToolchainSync(
-  starterDir: string,
-  canonicalFiles: Map<StarterToolchainSyncPath, string>,
-): StarterToolchainSyncChange[] {
-  const changes: StarterToolchainSyncChange[] = [];
-  for (const relativePath of STARTER_TOOLCHAIN_SYNC_PATHS) {
-    const canonicalContent = canonicalFiles.get(relativePath) ?? null;
-    const targetPath = path.join(starterDir, relativePath);
-    const existingContent = fs.existsSync(targetPath)
-      ? fs.readFileSync(targetPath, "utf-8")
-      : null;
-    const changed = existingContent !== canonicalContent;
-    if (changed) {
-      if (canonicalContent === null) {
-        if (fs.existsSync(targetPath)) {
-          fs.unlinkSync(targetPath);
-        }
-      } else {
-        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-        fs.writeFileSync(targetPath, canonicalContent);
-      }
-    }
-    changes.push({ relativePath, changed });
-  }
-  return changes;
-}
-
-export type SyncStarterManifestResult = {
-  changed: boolean;
-  packageChanged: boolean;
-  workspaceChanged: boolean;
-  packageJson: PackageJson;
-  pnpmWorkspaceYaml: string | null;
-  toolchainChanges: StarterToolchainSyncChange[];
-  changedToolchainPaths: StarterToolchainSyncPath[];
-  changedSourceMigrationPaths: string[];
-  sourceMigrationWarnings: string[];
-};
-
-export function resolveStarterPaths(options: {
-  starterDir?: string;
-  starterPackageJsonPath?: string;
-  starterPnpmWorkspacePath?: string;
-}): {
-  starterDir: string;
-  starterPackageJsonPath: string;
-  starterPnpmWorkspacePath: string;
-} {
-  if (options.starterDir) {
-    return {
-      starterDir: path.resolve(options.starterDir),
-      starterPackageJsonPath: path.join(
-        path.resolve(options.starterDir),
-        "package.json",
-      ),
-      starterPnpmWorkspacePath: path.join(
-        path.resolve(options.starterDir),
-        "pnpm-workspace.yaml",
-      ),
-    };
-  }
-  if (!options.starterPackageJsonPath) {
-    throw new Error("Provide --starter-dir or --starter-package-json.");
-  }
-  const starterPackageJsonPath = path.resolve(options.starterPackageJsonPath);
-  return {
-    starterDir: path.dirname(starterPackageJsonPath),
-    starterPackageJsonPath,
-    starterPnpmWorkspacePath:
-      options.starterPnpmWorkspacePath ??
-      path.join(path.dirname(starterPackageJsonPath), "pnpm-workspace.yaml"),
-  };
-}
-
-export function syncStarterManifestFiles(options: {
-  starterDir?: string;
-  starterPackageJsonPath?: string;
-  starterPnpmWorkspacePath?: string;
-  repoRoot?: string;
-  write?: boolean;
-}): SyncStarterManifestResult {
-  const { starterDir, starterPackageJsonPath, starterPnpmWorkspacePath } =
-    resolveStarterPaths(options);
-  const snapshot = createStandaloneChatSnapshot(options.repoRoot);
-
-  try {
-    const repoRoot = options.repoRoot ?? findAgentNativeRoot();
-    const initialStarterPackageJson = JSON.parse(
-      fs.readFileSync(starterPackageJsonPath, "utf-8"),
-    ) as PackageJson;
-    const sourceMigration = migrateStarterSources({
-      starterDir,
-      repoRoot,
-      coreVersion: resolveStarterCoreVersion(
-        initialStarterPackageJson,
-        repoRoot,
-      ),
-      write: options.write,
-    });
-    const starterPackageJson = JSON.parse(
-      fs.readFileSync(starterPackageJsonPath, "utf-8"),
-    ) as PackageJson;
-    const mergedPackageJson = mergeStarterManifest(
-      starterPackageJson,
-      snapshot.packageJson,
-    );
-
-    const existingWorkspace = fs.existsSync(starterPnpmWorkspacePath)
-      ? fs.readFileSync(starterPnpmWorkspacePath, "utf-8")
-      : null;
-
-    const workspaceChanged = workspaceFileSyncChanged(
-      existingWorkspace,
-      snapshot.pnpmWorkspaceYaml,
-    );
-    const packageChanged =
-      stableJson(starterPackageJson) !== stableJson(mergedPackageJson);
-    const toolchainChanges = diffStarterToolchainFiles(
-      starterDir,
-      snapshot.toolchainFiles,
-    );
-    const changedToolchainPaths = toolchainChanges
-      .filter((change) => change.changed)
-      .map((change) => change.relativePath);
-    const changed =
-      packageChanged ||
-      workspaceChanged ||
-      changedToolchainPaths.length > 0 ||
-      sourceMigration.changedPaths.length > 0;
-
-    if (options.write && changed) {
-      if (packageChanged) {
-        fs.writeFileSync(starterPackageJsonPath, stableJson(mergedPackageJson));
-      }
-      if (workspaceChanged) {
-        applyWorkspaceFileSync(
-          starterPnpmWorkspacePath,
-          snapshot.pnpmWorkspaceYaml,
-        );
-      }
-      if (changedToolchainPaths.length > 0) {
-        applyStarterToolchainSync(starterDir, snapshot.toolchainFiles);
-      }
-    }
-
-    return {
-      changed,
-      packageChanged,
-      workspaceChanged,
-      packageJson: mergedPackageJson,
-      pnpmWorkspaceYaml: snapshot.pnpmWorkspaceYaml,
-      toolchainChanges,
-      changedToolchainPaths,
-      changedSourceMigrationPaths: sourceMigration.changedPaths,
-      sourceMigrationWarnings: sourceMigration.warnings,
-    };
-  } finally {
-    snapshot.cleanup();
-  }
-}
-
-export function parseSyncStarterManifestArgs(argv: string[]): {
-  command: "merge" | "generate" | "paths";
-  starterDir?: string;
-  starterPackageJsonPath?: string;
-  starterPnpmWorkspacePath?: string;
-  write: boolean;
-  repoRoot?: string;
-} {
-  const [commandRaw, ...rest] = argv;
-  const command =
-    commandRaw === "generate"
-      ? "generate"
-      : commandRaw === "paths"
-        ? "paths"
-        : "merge";
-  let starterDir: string | undefined;
-  let starterPackageJsonPath: string | undefined;
-  let starterPnpmWorkspacePath: string | undefined;
-  let write = false;
-  let repoRoot: string | undefined;
-
-  for (let i = 0; i < rest.length; i++) {
-    const arg = rest[i];
-    if (arg === "--write") {
-      write = true;
-      continue;
-    }
-    if (arg === "--starter-dir") {
-      starterDir = rest[++i];
-      continue;
-    }
-    if (arg === "--starter-package-json") {
-      starterPackageJsonPath = rest[++i];
-      continue;
-    }
-    if (arg === "--starter-pnpm-workspace") {
-      starterPnpmWorkspacePath = rest[++i];
-      continue;
-    }
-    if (arg === "--repo-root") {
-      repoRoot = rest[++i];
-      continue;
-    }
-    throw new Error(`Unknown argument: ${arg}`);
-  }
-
-  if (command === "merge" && !starterDir && !starterPackageJsonPath) {
-    throw new Error(
-      "merge requires --starter-dir <path> or --starter-package-json <path> [--starter-pnpm-workspace <path>] [--write] [--repo-root <path>]",
-    );
-  }
-
-  return {
-    command,
-    starterDir,
-    starterPackageJsonPath,
-    starterPnpmWorkspacePath,
-    write,
-    repoRoot,
-  };
-}
-
-export function runSyncStarterManifestCli(argv: string[]): number {
-  const args = parseSyncStarterManifestArgs(argv);
-
-  if (args.command === "generate") {
-    const { packageJson, pnpmWorkspaceYaml } = generateStandaloneChatManifest(
-      args.repoRoot,
-    );
-    process.stdout.write(stableJson(packageJson));
-    if (pnpmWorkspaceYaml) {
-      process.stdout.write("\n--- pnpm-workspace.yaml ---\n");
-      process.stdout.write(pnpmWorkspaceYaml);
-    }
-    return 0;
-  }
-
-  if (args.command === "paths") {
-    for (const syncPath of listStarterSyncPaths()) {
-      process.stdout.write(`${syncPath}\n`);
-    }
-    return 0;
-  }
-
-  const result = syncStarterManifestFiles({
-    starterDir: args.starterDir,
-    starterPackageJsonPath: args.starterPackageJsonPath,
-    starterPnpmWorkspacePath: args.starterPnpmWorkspacePath,
-    repoRoot: args.repoRoot,
-    write: args.write,
-  });
-
-  for (const warning of result.sourceMigrationWarnings) {
-    console.warn(`[starter migration] ${warning}`);
-  }
-
-  if (result.changed) {
-    const updatedPaths = [
-      ...new Set([
-        ...(result.packageChanged ? ["package.json"] : []),
-        ...(result.workspaceChanged ? ["pnpm-workspace.yaml"] : []),
-        ...result.changedToolchainPaths,
-        ...result.changedSourceMigrationPaths,
-      ]),
-    ];
-    const summary = updatedPaths.length ? ` (${updatedPaths.join(", ")})` : "";
-    console.log(
-      args.write
-        ? `Updated builder-agent-native-starter from templates/chat${summary}.`
-        : `builder-agent-native-starter is out of date with templates/chat${summary}.`,
-    );
-    return args.write ? 0 : 1;
-  }
-
-  console.log("builder-agent-native-starter already matches templates/chat.");
-  return 0;
-}
-
-const isDirectRun =
-  process.argv[1] &&
-  path.resolve(process.argv[1]) ===
-    path.resolve(fileURLToPath(import.meta.url));
-
-if (isDirectRun) {
-  const exitCode = runSyncStarterManifestCli(process.argv.slice(2));
-  process.exit(exitCode);
-}