@apps-in-toss/cli 0.0.40 → 1.0.1

package/dist/index.js

@@ -785,7 +785,7 @@ import assert from "assert";
 import fs2 from "fs";
 import path from "path";
 import * as p from "@clack/prompts";
-import { getPackageRoot, readZipContent } from "@react-native-bedrock/utils";
+import { getPackageRoot, readZipContent } from "@granite-js/utils";
 import { Command, Option } from "clipanion";
 
 // src/utils/constants.ts
@@ -912,7 +912,7 @@ init_esm_shims();
 import fs3 from "fs";
 import path2 from "path";
 import * as p2 from "@clack/prompts";
-import { getPackageRoot as getPackageRoot2 } from "@react-native-bedrock/utils";
+import { getPackageRoot as getPackageRoot2 } from "@granite-js/utils";
 import { Command as Command2, Option as Option2 } from "clipanion";
 
 // ../../.yarn/cache/es-toolkit-npm-1.32.0-019fc7c155-56ba965570.zip/node_modules/es-toolkit/dist/index.mjs
@@ -957,9 +957,10 @@ export default defineConfig({
 });
 `;
 var REACT_NATIVE_FRAMEWORK_CONFIG_TEMPLATE = `import { appsInToss } from '@apps-in-toss/framework/plugins';
-import { defineConfig } from 'react-native-bedrock/config';
+import { defineConfig } from '@granite-js/react-native/config';
 
 export default defineConfig({
+  scheme: 'intoss',
   appName: '%%appName%%',
   plugins: [
     appsInToss({
@@ -976,7 +977,7 @@ export default defineConfig({
 `;
 var APP_TEMPLATE = `import { AppsInToss } from '@apps-in-toss/framework';
 import { PropsWithChildren } from 'react';
-import { InitialProps } from 'react-native-bedrock';
+import { InitialProps } from '@granite-js/react-native';
 import { context } from '../require.context';
 
 function AppContainer({ children }: PropsWithChildren<InitialProps>) {
@@ -1019,17 +1020,17 @@ async function templateWebFramework({ appName, cwd, skipInput }) {
     dev: scripts?.scripts?.dev || scripts?.scripts?.start,
     build: scripts?.scripts?.build
   };
-  scripts.scripts.dev = "bedrock dev";
-  scripts.scripts.build = "bedrock build";
+  scripts.scripts.dev = "granite dev";
+  scripts.scripts.build = "granite build";
   scripts.scripts.deploy = "ait deploy";
   await fs3.promises.writeFile(path2.join(cwd, "package.json"), JSON.stringify(scripts, null, 2), {
     encoding: "utf-8"
   });
   p2.log.step(".gitignore \uD30C\uC77C\uC744 \uC5C5\uB370\uC774\uD2B8\uD558\uB294 \uC911...");
-  await fs3.promises.appendFile(path2.join(cwd, ".gitignore"), "\n.bedrock\n");
+  await fs3.promises.appendFile(path2.join(cwd, ".gitignore"), "\n.granite\n");
   const placeholder = {
-    dev: originalScripts.dev === "bedrock dev" ? "" : originalScripts.dev,
-    build: originalScripts.build === "bedrock build" ? "" : originalScripts.build
+    dev: originalScripts.dev === "granite dev" ? "" : originalScripts.dev,
+    build: originalScripts.build === "granite build" ? "" : originalScripts.build
   };
   const scriptInputs = skipInput ? placeholder : await p2.group(
     {
@@ -1050,7 +1051,7 @@ async function templateWebFramework({ appName, cwd, skipInput }) {
       }
     }
   );
-  p2.log.step("bedrock.config.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
+  p2.log.step("granite.config.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
   const webPort = skipInput ? "5173" : await p2.text({
     message: "Enter web port",
     placeholder: "5173",
@@ -1063,19 +1064,19 @@ async function templateWebFramework({ appName, cwd, skipInput }) {
   const config = transformTemplate(WEB_FRAMEWORK_CONFIG_TEMPLATE, {
     appName,
     webPort,
-    webDevCommand: scriptInputs.dev === "bedrock dev" ? "" : scriptInputs.dev,
-    webBuildCommand: scriptInputs.build === "bedrock build" ? "" : scriptInputs.build
+    webDevCommand: scriptInputs.dev === "granite dev" ? "" : scriptInputs.dev,
+    webBuildCommand: scriptInputs.build === "granite build" ? "" : scriptInputs.build
   });
-  await fs3.promises.writeFile(path2.join(cwd, "bedrock.config.ts"), config, {
+  await fs3.promises.writeFile(path2.join(cwd, "granite.config.ts"), config, {
     encoding: "utf-8"
   });
 }
 async function templateReactNative({ appName, cwd }) {
-  p2.log.step("bedrock.config.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
+  p2.log.step("granite.config.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
   const config = transformTemplate(REACT_NATIVE_FRAMEWORK_CONFIG_TEMPLATE, {
     appName
   });
-  await fs3.promises.writeFile(path2.join(cwd, "bedrock.config.ts"), config, {
+  await fs3.promises.writeFile(path2.join(cwd, "granite.config.ts"), config, {
     encoding: "utf-8"
   });
   p2.log.step("src/_app.tsx \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
@@ -1101,8 +1102,8 @@ var InitCommand = class extends Command2 {
           },
           {
             value: "react-native",
-            label: "React Native \uD504\uB808\uC784\uC6CC\uD06C (Bedrock)",
-            hint: "Bedrock \uD504\uB85C\uC81D\uD2B8\uC5D0 \uC571\uC778\uD1A0\uC2A4 React Native\uC6A9 \uAC1C\uBC1C\uD658\uACBD\uC744 \uC138\uD305\uD569\uB2C8\uB2E4."
+            label: "React Native \uD504\uB808\uC784\uC6CC\uD06C (Granite)",
+            hint: "Granite \uD504\uB85C\uC81D\uD2B8\uC5D0 \uC571\uC778\uD1A0\uC2A4 React Native\uC6A9 \uAC1C\uBC1C\uD658\uACBD\uC744 \uC138\uD305\uD569\uB2C8\uB2E4."
           }
         ]
       })
@@ -1154,19 +1155,610 @@ var InitCommand = class extends Command2 {
   }
 };
 
+// src/MigrateCommand/index.ts
+init_esm_shims();
+
+// src/MigrateCommand/MigrateCommand.ts
+init_esm_shims();
+import { Command as Command3, Option as Option3 } from "clipanion";
+
+// src/MigrateCommand/logger/index.ts
+init_esm_shims();
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+var Logger = class {
+  prefix = import_picocolors2.default.bold(import_picocolors2.default.bgCyan(import_picocolors2.default.black(" MIGRATE ")));
+  log(...args) {
+    console.log(this.prefix, ...args);
+  }
+  success(...args) {
+    console.log(this.prefix, import_picocolors2.default.green("\u2713"), ...args);
+  }
+  error(...args) {
+    console.error(this.prefix, import_picocolors2.default.red("\u2717"), ...args);
+  }
+  warn(...args) {
+    console.warn(this.prefix, import_picocolors2.default.yellow("!"), ...args);
+  }
+};
+var logger = new Logger();
+
+// src/MigrateCommand/presets/index.ts
+init_esm_shims();
+
+// src/MigrateCommand/presets/granite/index.ts
+init_esm_shims();
+
+// src/MigrateCommand/presets/granite/migrateGranite.ts
+init_esm_shims();
+import assert2 from "assert";
+import dedent from "dedent";
+
+// src/MigrateCommand/presets/granite/configProcessor.ts
+init_esm_shims();
+
+// src/MigrateCommand/fs/fileProcessor.ts
+init_esm_shims();
+import { promises as fs4 } from "fs";
+async function readFile(filePath) {
+  try {
+    return await fs4.readFile(filePath, "utf-8");
+  } catch {
+    throw new Error(`Failed to read file: ${filePath}`);
+  }
+}
+async function writeFile(filePath, content) {
+  try {
+    await fs4.writeFile(filePath, content, "utf-8");
+  } catch {
+    throw new Error(`Failed to write file: ${filePath}`);
+  }
+}
+async function fileExists(filePath) {
+  try {
+    await fs4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function renameFile(oldPath, newPath) {
+  try {
+    await fs4.rename(oldPath, newPath);
+  } catch {
+    throw new Error(`Failed to rename file: ${oldPath} -> ${newPath}`);
+  }
+}
+
+// src/MigrateCommand/presets/granite/configProcessor.ts
+var configTransformer = (root, { j }) => {
+  root.find(j.ImportDeclaration).forEach((path5) => {
+    const source = path5.value.source;
+    if (j.StringLiteral.check(source) && source.value === "react-native-bedrock/config") {
+      const defineConfigName = path5.value.specifiers?.find(
+        (specifier) => j.ImportSpecifier.check(specifier) && specifier.imported.name === "defineConfig"
+      )?.local?.name;
+      if (!defineConfigName) {
+        return;
+      }
+      root.find(j.CallExpression).forEach((path6) => {
+        const callee = path6.value.callee;
+        if (j.Identifier.check(callee) && callee.name === defineConfigName && path6.value.arguments.length > 0 && j.ObjectExpression.check(path6.value.arguments[0])) {
+          const obj = path6.value.arguments[0];
+          const hasScheme = obj.properties.some(
+            (prop) => j.ObjectProperty.check(prop) && j.Identifier.check(prop.key) && prop.key.name === "scheme"
+          );
+          if (!hasScheme) {
+            obj.properties.unshift(j.objectProperty(j.identifier("scheme"), j.stringLiteral("intoss")));
+          }
+          const routerImport = root.find(j.ImportDeclaration).filter((path7) => {
+            const source2 = path7.value.source;
+            return j.StringLiteral.check(source2) && source2.value === "@granite-js/plugin-router";
+          });
+          if (routerImport.length === 0) {
+            const firstImport = root.find(j.ImportDeclaration).at(0);
+            if (firstImport.length > 0) {
+              firstImport.insertAfter(
+                j.importDeclaration(
+                  [j.importSpecifier(j.identifier("router"))],
+                  j.stringLiteral("@granite-js/plugin-router")
+                )
+              );
+            }
+          }
+          const hasPlugins = obj.properties.some(
+            (prop) => j.ObjectProperty.check(prop) && j.Identifier.check(prop.key) && prop.key.name === "plugins"
+          );
+          const routerPluginCallExpr = j.callExpression(j.identifier("router"), []);
+          if (hasPlugins) {
+            const pluginsProp = obj.properties.find(
+              (prop) => j.ObjectProperty.check(prop) && j.Identifier.check(prop.key) && prop.key.name === "plugins"
+            );
+            if (j.ObjectProperty.check(pluginsProp) && j.ArrayExpression.check(pluginsProp.value)) {
+              const hasRouter = pluginsProp.value.elements.some(
+                (element) => j.Identifier.check(element) && element.name === "router"
+              );
+              if (!hasRouter) {
+                pluginsProp.value.elements.push(routerPluginCallExpr);
+              }
+            }
+          } else {
+            obj.properties.unshift(
+              j.objectProperty(j.identifier("plugins"), j.arrayExpression([routerPluginCallExpr]))
+            );
+          }
+        }
+      });
+    }
+  });
+  return root;
+};
+var processBedrockConfig = async (cwd, config) => {
+  logger.log("Processing bedrock.config.ts...");
+  const bedrockConfigPath = `${cwd}/bedrock.config.ts`;
+  const graniteConfigPath = `${cwd}/granite.config.ts`;
+  if (!await fileExists(bedrockConfigPath)) {
+    logger.log("No bedrock.config.ts found");
+    return;
+  }
+  if (config.dryRun) {
+    return;
+  }
+  try {
+    await renameFile(bedrockConfigPath, graniteConfigPath);
+    logger.success("Renamed bedrock.config.ts to granite.config.ts");
+  } catch (error) {
+    logger.error(`Failed to process bedrock.config.ts: ${error}`);
+  }
+};
+
+// src/MigrateCommand/presets/granite/gitignoreProcessor.ts
+init_esm_shims();
+var processGitignore = async (cwd, config) => {
+  let modified = false;
+  logger.log("Processing .gitignore...");
+  const gitignorePath = `${cwd}/.gitignore`;
+  try {
+    if (await fileExists(gitignorePath)) {
+      const content = await readFile(gitignorePath);
+      const newContent = content.replace(/\.bedrock/g, ".granite");
+      if (newContent !== content) {
+        if (config.dryRun) {
+          logger.log("Skipping file write in dry run mode");
+        } else {
+          await writeFile(gitignorePath, newContent);
+          logger.success("Updated .gitignore");
+        }
+        modified ||= true;
+      } else {
+        logger.log(`No changes needed in ${gitignorePath}`);
+      }
+    }
+  } catch (error) {
+    logger.error(`Failed to process .gitignore: ${error}`);
+  }
+  if (!modified) {
+    logger.log("No .gitignore found");
+    return;
+  }
+};
+
+// src/MigrateCommand/presets/granite/identifierReplacements.ts
+init_esm_shims();
+
+// src/MigrateCommand/codemod/utils.ts
+init_esm_shims();
+function getIdentifierName(j, id) {
+  if (typeof id === "string") {
+    return id;
+  }
+  if (j.Identifier.check(id)) {
+    return id.name;
+  }
+  return "";
+}
+
+// src/MigrateCommand/presets/granite/identifierReplacements.ts
+var identifierReplacementsTransformer = (root, { j }) => {
+  const importedVariables = /* @__PURE__ */ new Set();
+  function toGraniteName(name) {
+    let newName = null;
+    if (name === "BedrockRoute") {
+      newName = "createRoute";
+    } else if (name.startsWith("bedrock")) {
+      newName = toGraniteCamel(name);
+    } else if (name.startsWith("Bedrock")) {
+      newName = toGranitePascal(name);
+    } else if (name.startsWith("BEDROCK")) {
+      newName = toGraniteSnake(name);
+    }
+    return newName;
+  }
+  function toGraniteCamel(name) {
+    const rest = name.substring(7);
+    return "granite" + rest;
+  }
+  function toGranitePascal(name) {
+    const rest = name.substring(7);
+    return "Granite" + rest;
+  }
+  function toGraniteSnake(name) {
+    const rest = name.substring(7);
+    return "GRANITE" + rest;
+  }
+  root.find(j.ImportDeclaration, { source: { value: "react-native-bedrock" } }).forEach((importPath) => {
+    importPath.value.specifiers?.forEach((specifier) => {
+      if (j.ImportSpecifier.check(specifier)) {
+        const importedName = getIdentifierName(j, specifier.imported);
+        const localName = specifier.local ? getIdentifierName(j, specifier.local) : importedName;
+        if (j.Identifier.check(specifier.imported)) {
+          const newName = toGraniteName(importedName);
+          if (newName) {
+            specifier.imported.name = newName;
+          }
+        }
+        importedVariables.add(localName);
+      }
+    });
+  });
+  root.find(j.Identifier).forEach((path5) => {
+    const name = path5.value.name;
+    if (importedVariables.has(name)) {
+      const newName = toGraniteName(path5.value.name);
+      if (newName) {
+        path5.value.name = newName;
+      }
+    }
+  });
+  return root;
+};
+
+// src/MigrateCommand/presets/granite/isBedrockProject.ts
+init_esm_shims();
+import * as fs5 from "fs";
+var BASE_NAME = "bedrock.config";
+var EXTENSIONS = ["ts", "mts", "js", "cjs"];
+async function isBedrockProject(cwd) {
+  const files = fs5.readdirSync(cwd);
+  return files.some(isBedrockConfigFile);
+}
+function isBedrockConfigFile(file) {
+  return EXTENSIONS.some((ext) => file === `${BASE_NAME}.${ext}`);
+}
+
+// src/MigrateCommand/presets/granite/packageImports.ts
+init_esm_shims();
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+
+// src/MigrateCommand/presets/granite/constants.ts
+init_esm_shims();
+var UNSUPPORTED_LIBRARIES = [
+  "@react-native-bedrock/e2e-testing-library",
+  "@react-native-bedrock/babel-plugin-obfuscate"
+];
+var TARGET_VERSION = {
+  granitePackages: "0.1.21",
+  appsInTossPackages: "^1.0.0",
+  tossDesignSystem: "^1.0.4"
+};
+
+// src/MigrateCommand/presets/granite/packageImports.ts
+var packageImportsTransformer = (root, { j }, { fileName = "<unknown>" }) => {
+  function transformPackageName(value) {
+    if (UNSUPPORTED_LIBRARIES.includes(value)) {
+      const libName = import_picocolors3.default.gray(`(${value})`);
+      logger.warn(`Unsupported library found ${libName}`);
+      logger.warn(`\u2514\u2500 ${import_picocolors3.default.gray(`at ${fileName}`)}`);
+      return value;
+    }
+    if (value === "react-native-bedrock" || value.startsWith("react-native-bedrock/")) {
+      return value.replace("react-native-bedrock", "@granite-js/react-native");
+    }
+    if (value.startsWith("@react-native-bedrock/")) {
+      return value.replace("@react-native-bedrock/", "@granite-js/");
+    }
+    return value;
+  }
+  root.find(j.ImportDeclaration).forEach((path5) => {
+    const source = path5.value.source;
+    if (j.StringLiteral.check(source)) {
+      const transformed = transformPackageName(source.value);
+      if (transformed !== source.value) {
+        source.value = transformed;
+      }
+    }
+  });
+  root.find(j.CallExpression, {
+    callee: { name: "require" }
+  }).forEach((path5) => {
+    const args = path5.value.arguments;
+    if (args.length > 0 && j.StringLiteral.check(args[0])) {
+      const transformed = transformPackageName(args[0].value);
+      if (transformed !== args[0].value) {
+        args[0].value = transformed;
+      }
+    }
+  });
+  root.find(j.ImportExpression).forEach((path5) => {
+    const source = path5.value.source;
+    if (j.StringLiteral.check(source)) {
+      const transformed = transformPackageName(source.value);
+      if (transformed !== source.value) {
+        source.value = transformed;
+      }
+    }
+  });
+  return root;
+};
+
+// src/MigrateCommand/presets/granite/packageJsonProcessor.ts
+init_esm_shims();
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+var processPackageJson = async (cwd, config) => {
+  logger.log("Processing package.json...");
+  const packageJsonPath = `${cwd}/package.json`;
+  if (!await fileExists(packageJsonPath)) {
+    logger.log("No package.json found");
+    return;
+  }
+  try {
+    const content = await readFile(packageJsonPath);
+    const packageJson = JSON.parse(content);
+    let modified = false;
+    const depFields = ["dependencies", "devDependencies", "peerDependencies"];
+    for (const field of depFields) {
+      if (packageJson[field]) {
+        const deps = packageJson[field];
+        const newDeps = {
+          "@granite-js/plugin-router": TARGET_VERSION.granitePackages
+        };
+        for (const [originLibName, originLibVersion] of Object.entries(deps)) {
+          let libName = originLibName;
+          let libVersion = originLibVersion;
+          if (originLibName === "react-native-bedrock") {
+            libName = "@granite-js/react-native";
+            libVersion = TARGET_VERSION.granitePackages;
+          } else if (originLibName.startsWith("@react-native-bedrock/")) {
+            if (UNSUPPORTED_LIBRARIES.includes(originLibName)) {
+              const packageName = import_picocolors4.default.gray(`(${originLibName})`);
+              logger.warn(`Unsupported library found in package.json ${packageName}`);
+            } else {
+              libName = originLibName.replace("@react-native-bedrock", "@granite-js");
+              libVersion = TARGET_VERSION.granitePackages;
+            }
+          }
+          if (libName.startsWith("@apps-in-toss/")) {
+            libVersion = TARGET_VERSION.appsInTossPackages;
+          } else if (libName === "@toss-design-system/react-native") {
+            libVersion = TARGET_VERSION.tossDesignSystem;
+          }
+          newDeps[libName] = libVersion;
+          modified ||= libName !== originLibName;
+        }
+        packageJson[field] = newDeps;
+      }
+    }
+    if (packageJson.scripts) {
+      const scripts = packageJson.scripts;
+      for (const [key, value] of Object.entries(scripts)) {
+        if (typeof value === "string" && value.includes("bedrock")) {
+          scripts[key] = value.replace(/\bbedrock\b/g, "granite");
+          modified ||= true;
+        }
+      }
+    }
+    if (config.dryRun) {
+      return;
+    }
+    if (modified) {
+      await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+      logger.success("Updated package.json");
+    } else {
+      logger.log("No changes needed in package.json");
+    }
+  } catch (error) {
+    logger.error(`Failed to process package.json: ${error}`);
+  }
+};
+
+// src/MigrateCommand/presets/granite/toAppsInTossFrameworkImport.ts
+init_esm_shims();
+var APPS_IN_TOSS_FRAMEWORK_EXPORTS = [
+  "closeView",
+  "getLocale",
+  "getSchemeUri",
+  "generateHapticFeedback",
+  "share",
+  "setSecureScreen",
+  "setScreenAwakeMode",
+  "getNetworkStatus",
+  "setIosSwipeGestureEnabled",
+  "openURL",
+  "getPlatformOS"
+];
+var toAppsInTossFrameworkImport = (root, { j }, { fileName = "<unknown>" }) => {
+  const appsInTossFrameworkMembers = [];
+  root.find(j.ImportDeclaration).forEach((path5) => {
+    const source = path5.node.source.value;
+    if (typeof source !== "string") {
+      return;
+    }
+    if (source === "@granite-js/react-native") {
+      if (Array.isArray(path5.node.specifiers)) {
+        path5.node.specifiers = path5.node.specifiers.filter((specifier) => {
+          if (shouldImportFromAppsInTossFramework(fileName, specifier)) {
+            appsInTossFrameworkMembers.push(specifier);
+            return false;
+          }
+          return true;
+        });
+      }
+      if (path5.node.specifiers?.length === 0) {
+        j(path5).remove();
+      }
+    }
+  });
+  if (appsInTossFrameworkMembers.length > 0) {
+    const importStatement = j.importDeclaration(appsInTossFrameworkMembers, j.literal("@apps-in-toss/framework"));
+    root.find(j.Program).get("body", 0).insertBefore(importStatement);
+  }
+  return root;
+};
+function shouldImportFromAppsInTossFramework(fileName, specifier) {
+  switch (specifier.type) {
+    case "ImportSpecifier":
+      return APPS_IN_TOSS_FRAMEWORK_EXPORTS.includes(String(specifier.imported.name));
+    case "ImportDefaultSpecifier":
+    case "ImportNamespaceSpecifier":
+    default:
+      logger.warn(`Unknown import specifier in ${fileName}`);
+      return false;
+  }
+}
+
+// src/MigrateCommand/codemod/index.ts
+init_esm_shims();
+
+// src/MigrateCommand/codemod/transform.ts
+init_esm_shims();
+import jscodeshift from "jscodeshift";
+function transform(source, { transformers: transformers2, options = {} }) {
+  const j = jscodeshift.withParser("tsx");
+  const report = [];
+  const stats = /* @__PURE__ */ new Map();
+  const context = {
+    j,
+    jscodeshift: j,
+    stats: (name, quantity = 1) => {
+      if (quantity === 0) {
+        return;
+      }
+      stats.set(name, (stats.get(name) ?? 0) + quantity);
+    },
+    report: (message) => {
+      report.push(message);
+    }
+  };
+  const root = transformers2.reduce((root2, transformer) => transformer(root2, context, options), j(source));
+  return root.toSource();
+}
+
+// src/MigrateCommand/fs/fileScanner.ts
+init_esm_shims();
+import glob from "fast-glob";
+var DEFAULT_EXTENSIONS = ["js", "ts", "jsx", "tsx", "cjs", "mjs"];
+var DEFAULT_EXCLUDE_PATTERNS = ["**/node_modules/**", "**/.git/**", "**/dist/**"];
+async function scanFiles(directory, options = {}) {
+  const { extensions = DEFAULT_EXTENSIONS, excludePatterns = DEFAULT_EXCLUDE_PATTERNS } = options;
+  const patterns = extensions.map((ext) => `**/*.${ext}`);
+  const files = await glob(patterns, {
+    cwd: directory,
+    absolute: true,
+    ignore: excludePatterns
+  });
+  return files;
+}
+
+// src/MigrateCommand/presets/granite/migrateGranite.ts
+var transformers = [
+  configTransformer,
+  identifierReplacementsTransformer,
+  packageImportsTransformer,
+  toAppsInTossFrameworkImport
+];
+var migrateGranite = async (cwd, config) => {
+  assert2(isBedrockProject(cwd), "This is not a Bedrock project");
+  let processedCount = 0;
+  const files = await scanFiles(cwd);
+  logger.log(`Found ${files.length} source files`);
+  logger.log("Processing source files...");
+  for (const file of files) {
+    try {
+      const content = await readFile(file);
+      const newContent = await transform(content, {
+        transformers,
+        options: {
+          fileName: file
+        }
+      });
+      if (config.dryRun !== true && newContent !== content) {
+        await writeFile(file, newContent);
+        processedCount++;
+      }
+    } catch (error) {
+      logger.error(`Failed to process file: ${file}`, error);
+    }
+  }
+  if (processedCount > 0) {
+    logger.success(`Processed ${processedCount} source files`);
+  } else {
+    logger.log("No source files needed processing");
+  }
+  await processPackageJson(cwd, config);
+  await processGitignore(cwd, config);
+  await processBedrockConfig(cwd, config);
+  logger.log(dedent`
+  Please check the following steps:
+
+  - Install dependencies
+  - Run type checks
+  - Run lint checks if a lint config exists
+  - Verify test results if tests are present\n
+  `);
+};
+
+// src/MigrateCommand/presets/index.ts
+var MIGRATE_PRESETS = {
+  granite: migrateGranite
+};
+
+// src/MigrateCommand/MigrateCommand.ts
+var MigrateCommand = class extends Command3 {
+  static paths = [[`migrate`]];
+  static usage = Command3.Usage({
+    category: "Migration",
+    description: "Run migration",
+    examples: [
+      ["Run migration", "ait migrate <target>"],
+      ["Check migration availability", "ait migrate <target> --dryRun"]
+    ]
+  });
+  target = Option3.String({ required: true });
+  dryRun = Option3.Boolean("--dry-run", { required: false });
+  async execute() {
+    try {
+      const cwd = process.cwd();
+      const config = {
+        dryRun: this.dryRun
+      };
+      logger.log("Starting migration...");
+      logger.log(`Working directory: ${cwd}`);
+      const migrate = MIGRATE_PRESETS[this.target];
+      if (migrate == null) {
+        throw new Error(`Unknown target: ${this.target}`);
+      }
+      await migrate(cwd, config);
+      logger.success("Migration completed successfully!");
+      return 0;
+    } catch (error) {
+      logger.error(`Migration failed: ${error.message}`);
+      return 1;
+    }
+  }
+};
+
 // src/integrations/UploadSentrySourcemap/index.ts
 init_esm_shims();
 
 // src/integrations/UploadSentrySourcemap/UploadSentrySourcemap.ts
 init_esm_shims();
-import * as fs7 from "fs/promises";
+import * as fs9 from "fs/promises";
 import * as p3 from "@clack/prompts";
-import { Command as Command3, Option as Option3 } from "clipanion";
+import { Command as Command4, Option as Option4 } from "clipanion";
 
 // src/integrations/UploadSentrySourcemap/downloadArtifacts.ts
 init_esm_shims();
 var import_debug4 = __toESM(require_src(), 1);
-import * as fs4 from "fs";
+import * as fs6 from "fs";
 import * as os from "os";
 import * as path3 from "path";
 import { pipeline } from "stream";
@@ -1197,34 +1789,34 @@ async function downloadArtifacts(options) {
   const tmpDir = await createTempDirectory();
   const tmpFile = `${deploymentId}.zip`;
   const tmpFilePath = path3.join(tmpDir.path, tmpFile);
-  const fileStream = fs4.createWriteStream(tmpFilePath);
+  const fileStream = fs6.createWriteStream(tmpFilePath);
   await streamPipeline(response.body, fileStream);
   debug4("Artifacts downloaded", { tmpFilePath });
   return tmpFilePath;
 }
 function createTempDirectory() {
   const tempDir = path3.join(os.tmpdir(), "apps-in-toss", "sentry-integration");
-  fs4.mkdirSync(tempDir, { recursive: true });
+  fs6.mkdirSync(tempDir, { recursive: true });
   debug4("Temp directory created", { tempDir });
   return {
     path: tempDir,
     cleanup: () => {
-      fs4.rmSync(tempDir, { recursive: true, force: true });
+      fs6.rmSync(tempDir, { recursive: true, force: true });
     }
   };
 }
 
 // src/integrations/UploadSentrySourcemap/extractSentryDebugId.ts
 init_esm_shims();
-import fs5 from "fs/promises";
+import fs7 from "fs/promises";
 async function extractSentryDebugId(bundlePath) {
-  const bundleContent = await fs5.readFile(bundlePath, "utf-8");
+  const bundleContent = await fs7.readFile(bundlePath, "utf-8");
   return bundleContent.match(/SENTRY_DEBUG_ID=([\w-]+)/)?.[1];
 }
 
 // src/integrations/UploadSentrySourcemap/extractSources.ts
 init_esm_shims();
-import * as fs6 from "fs";
+import * as fs8 from "fs";
 import * as path4 from "path";
 import { pipeline as pipeline2 } from "stream";
 import { promisify as promisify2 } from "util";
@@ -1246,12 +1838,12 @@ async function extractSources(zipPath) {
       hermesSourceMap: ""
     }
   };
-  await fs6.createReadStream(zipPath).pipe(unzipper.Parse()).on("entry", async (entry) => {
+  await fs8.createReadStream(zipPath).pipe(unzipper.Parse()).on("entry", async (entry) => {
     const isRoot = !entry.path.includes("/");
     const fileName = path4.basename(entry.path);
     const outputPath = path4.join(path4.dirname(zipPath), fileName);
     if (isRoot) {
-      entry.pipe(fs6.createWriteStream(outputPath));
+      entry.pipe(fs8.createWriteStream(outputPath));
       const platform = fileName.includes("android") ? "android" : "ios";
       if (fileName.endsWith(".js")) {
         sources[platform].packagerBundle = outputPath;
@@ -1279,7 +1871,7 @@ async function extractSources(zipPath) {
 }
 async function decompressGzip(gzFile) {
   const outfile = gzFile.replace(/\.gz$/g, "");
-  await pipe(fs6.createReadStream(gzFile), zlib.createGunzip(), fs6.createWriteStream(outfile));
+  await pipe(fs8.createReadStream(gzFile), zlib.createGunzip(), fs8.createWriteStream(outfile));
   return outfile;
 }
 
@@ -1310,33 +1902,33 @@ function uploadSourcemap(bundlePath, sourcemapPath, options) {
 }
 
 // src/integrations/UploadSentrySourcemap/UploadSentrySourcemap.ts
-var UploadSentrySourcemap = class extends Command3 {
+var UploadSentrySourcemap = class extends Command4 {
   static paths = [["sentry", "upload-sourcemap"]];
-  apiKey = Option3.String("--api-key", {
+  apiKey = Option4.String("--api-key", {
     required: false,
     description: "\uC778\uC99D API \uD0A4"
   });
-  appName = Option3.String("--app-name", {
+  appName = Option4.String("--app-name", {
     required: false,
     description: "\uC571 \uC774\uB984"
   });
-  deploymentId = Option3.String("--deployment-id", {
+  deploymentId = Option4.String("--deployment-id", {
     required: false,
     description: "\uBC30\uD3EC ID"
   });
-  sentryAuthToken = Option3.String("--sentry-auth-token", {
+  sentryAuthToken = Option4.String("--sentry-auth-token", {
     required: false,
     description: "Sentry \uC778\uC99D\uD0A4"
   });
-  sentryOrg = Option3.String("--sentry-org", {
+  sentryOrg = Option4.String("--sentry-org", {
     required: false,
     description: "Sentry \uC870\uC9C1"
   });
-  sentryProject = Option3.String("--sentry-project", {
+  sentryProject = Option4.String("--sentry-project", {
     required: false,
     description: "Sentry \uD504\uB85C\uC81D\uD2B8"
   });
-  baseUrl = Option3.String("--base-url", {
+  baseUrl = Option4.String("--base-url", {
     description: "API Base URL"
   });
   async execute() {
@@ -1392,11 +1984,11 @@ var UploadSentrySourcemap = class extends Command3 {
       throw new Error("Sentry Debug ID\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
     }
     const mergedSourceMap = await mergeSourceMaps(
-      await fs7.readFile(sources.packagerSourceMap, "utf-8"),
-      await fs7.readFile(sources.hermesSourceMap, "utf-8")
+      await fs9.readFile(sources.packagerSourceMap, "utf-8"),
+      await fs9.readFile(sources.hermesSourceMap, "utf-8")
     );
     const injectedSourceMap = injectSentryDebugId(mergedSourceMap, debugId);
-    await fs7.writeFile(sources.hermesSourceMap, JSON.stringify(injectedSourceMap, null, 2), "utf-8");
+    await fs9.writeFile(sources.hermesSourceMap, JSON.stringify(injectedSourceMap, null, 2), "utf-8");
   }
   async promptRequiredValue(type, message, validateMessage) {
     const result = await p3[type]({
@@ -1423,6 +2015,7 @@ function initialize() {
   });
   cli.register(DeployCommand);
   cli.register(InitCommand);
+  cli.register(MigrateCommand);
   cli.register(UploadSentrySourcemap);
   cli.runExit(process.argv.slice(2));
 }