strapi2front 0.1.0

package/dist/index.js

@@ -0,0 +1,669 @@
+#!/usr/bin/env node
+import { loadConfig, detectStrapiVersion, fetchSchema, parseSchema } from '@strapi2front/core';
+export { defineConfig } from '@strapi2front/core';
+import * as p from '@clack/prompts';
+import pc4 from 'picocolors';
+import fs4 from 'fs/promises';
+import path5 from 'path';
+import { execSync } from 'child_process';
+import fs5 from 'fs';
+import { generateByFeature, generateTypes, generateClient, generateLocales, generateServices, generateActions } from '@strapi2front/generators';
+
+var FRAMEWORK_DETECTORS = {
+  astro: {
+    name: "astro",
+    configFiles: ["astro.config.mjs", "astro.config.ts", "astro.config.js"]
+  },
+  next: {
+    name: "nextjs",
+    configFiles: ["next.config.mjs", "next.config.ts", "next.config.js"]
+  },
+  nuxt: {
+    name: "nuxt",
+    configFiles: ["nuxt.config.ts", "nuxt.config.js"]
+  }
+};
+async function detectFramework(cwd = process.cwd()) {
+  const pkgPath = path5.join(cwd, "package.json");
+  try {
+    const pkgContent = await fs4.readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgContent);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    for (const [pkgName, detector] of Object.entries(FRAMEWORK_DETECTORS)) {
+      if (deps[pkgName]) {
+        for (const configFile of detector.configFiles) {
+          const configPath = path5.join(cwd, configFile);
+          try {
+            await fs4.access(configPath);
+            return {
+              name: detector.name,
+              version: deps[pkgName],
+              configFile
+            };
+          } catch {
+          }
+        }
+        return {
+          name: detector.name,
+          version: deps[pkgName],
+          configFile: null
+        };
+      }
+    }
+  } catch {
+  }
+  return {
+    name: "unknown",
+    version: null,
+    configFile: null
+  };
+}
+function getFrameworkDisplayName(framework) {
+  const names = {
+    astro: "Astro",
+    nextjs: "Next.js",
+    nuxt: "Nuxt",
+    unknown: "Unknown"
+  };
+  return names[framework];
+}
+var TS_CONFIG_FILES = ["tsconfig.json", "tsconfig.app.json"];
+async function detectTypeScript(cwd = process.cwd()) {
+  for (const configFile of TS_CONFIG_FILES) {
+    const configPath = path5.join(cwd, configFile);
+    try {
+      await fs4.access(configPath);
+      const pkgPath = path5.join(cwd, "package.json");
+      try {
+        const pkgContent = await fs4.readFile(pkgPath, "utf-8");
+        const pkg = JSON.parse(pkgContent);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return {
+          enabled: true,
+          configFile,
+          version: deps.typescript || null
+        };
+      } catch {
+        return {
+          enabled: true,
+          configFile,
+          version: null
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    enabled: false,
+    configFile: null,
+    version: null
+  };
+}
+var LOCK_FILES = {
+  "pnpm-lock.yaml": "pnpm",
+  "package-lock.json": "npm",
+  "yarn.lock": "yarn",
+  "bun.lockb": "bun"
+};
+async function detectPackageManager(cwd = process.cwd()) {
+  for (const [lockFile, pm] of Object.entries(LOCK_FILES)) {
+    const lockPath = path5.join(cwd, lockFile);
+    try {
+      await fs4.access(lockPath);
+      return {
+        name: pm,
+        lockFile
+      };
+    } catch {
+    }
+  }
+  return {
+    name: "npm",
+    lockFile: null
+  };
+}
+function getInstallCommand(pm, pkg) {
+  const commands = {
+    pnpm: `pnpm add ${pkg}`,
+    npm: `npm install ${pkg}`,
+    yarn: `yarn add ${pkg}`,
+    bun: `bun add ${pkg}`
+  };
+  return commands[pm];
+}
+async function runInitPrompts(detection) {
+  p.intro(pc4.cyan("strapi-integrate setup"));
+  p.note(
+    [
+      `Framework: ${pc4.green(getFrameworkDisplayName(detection.framework.name))} ${detection.framework.version ? pc4.dim(`v${detection.framework.version}`) : ""}`,
+      `TypeScript: ${detection.typescript.enabled ? pc4.green("enabled") : pc4.yellow("disabled")}`,
+      `Package Manager: ${pc4.green(detection.packageManager.name)}`
+    ].join("\n"),
+    "Detected Configuration"
+  );
+  if (detection.framework.name === "unknown") {
+    p.cancel("Could not detect a supported framework. Currently only Astro is supported.");
+    return null;
+  }
+  if (detection.framework.name !== "astro") {
+    p.cancel(`${detection.framework.name} is not yet supported. Currently only Astro is supported.`);
+    return null;
+  }
+  const defaultUrl = "http://localhost:1337";
+  const strapiUrlInput = await p.text({
+    message: "What is your Strapi URL?",
+    placeholder: `${defaultUrl} (press Enter for default)`,
+    validate: (value) => {
+      const trimmed = (value || "").trim();
+      if (trimmed === "") return void 0;
+      try {
+        new URL(trimmed);
+        return void 0;
+      } catch {
+        return "Please enter a valid URL";
+      }
+    }
+  });
+  if (p.isCancel(strapiUrlInput)) {
+    p.cancel("Setup cancelled");
+    return null;
+  }
+  const strapiUrl = (strapiUrlInput || "").trim() || defaultUrl;
+  const strapiToken = await p.text({
+    message: "What is your Strapi API token?",
+    placeholder: "Press Enter to skip (you can add it later in .env)"
+  });
+  if (p.isCancel(strapiToken)) {
+    p.cancel("Setup cancelled");
+    return null;
+  }
+  const trimmedToken = (strapiToken || "").trim();
+  if (trimmedToken === "") {
+    p.log.info(pc4.dim("Token skipped. Remember to add STRAPI_TOKEN to your .env file later."));
+  }
+  const strapiVersion = await p.select({
+    message: "What version of Strapi are you using?",
+    options: [
+      { value: "v5", label: "Strapi v5", hint: "Recommended - Latest version" },
+      { value: "v4", label: "Strapi v4", hint: "Legacy version" }
+    ],
+    initialValue: "v5"
+  });
+  if (p.isCancel(strapiVersion)) {
+    p.cancel("Setup cancelled");
+    return null;
+  }
+  p.log.info(pc4.dim(`Using Strapi ${strapiVersion}. This can be changed later in strapi.config.ts`));
+  const outputDir = await p.text({
+    message: "Where should we generate the Strapi files?",
+    placeholder: "src/strapi",
+    defaultValue: "src/strapi"
+  });
+  if (p.isCancel(outputDir)) {
+    p.cancel("Setup cancelled");
+    return null;
+  }
+  const features = await p.multiselect({
+    message: "What would you like to generate?",
+    options: [
+      { value: "types", label: "Types", hint: "TypeScript interfaces for your content types" },
+      { value: "services", label: "Services", hint: "Typed service functions for data fetching" },
+      { value: "actions", label: "Astro Actions", hint: "Type-safe actions for client/server" }
+    ],
+    initialValues: ["types", "services", "actions"],
+    required: true
+  });
+  if (p.isCancel(features)) {
+    p.cancel("Setup cancelled");
+    return null;
+  }
+  return {
+    strapiUrl,
+    strapiToken: trimmedToken,
+    strapiVersion,
+    outputDir: (outputDir || "").trim() || "src/strapi",
+    generateActions: features.includes("actions"),
+    generateServices: features.includes("services")
+  };
+}
+var logger = {
+  info: (message) => {
+    console.log(pc4.blue("i"), message);
+  },
+  success: (message) => {
+    console.log(pc4.green("v"), message);
+  },
+  warn: (message) => {
+    console.log(pc4.yellow("!"), message);
+  },
+  error: (message) => {
+    console.log(pc4.red("x"), message);
+  },
+  step: (message) => {
+    console.log(pc4.cyan(">"), message);
+  },
+  dim: (message) => {
+    console.log(pc4.dim(message));
+  },
+  newLine: () => {
+    console.log("");
+  }
+};
+
+// src/commands/init.ts
+async function initCommand(_options) {
+  const cwd = process.cwd();
+  const s = p.spinner();
+  s.start("Detecting project configuration...");
+  const [framework, typescript, packageManager] = await Promise.all([
+    detectFramework(cwd),
+    detectTypeScript(cwd),
+    detectPackageManager(cwd)
+  ]);
+  s.stop("Project configuration detected");
+  const answers = await runInitPrompts({
+    framework,
+    typescript,
+    packageManager
+  });
+  if (!answers) {
+    return;
+  }
+  s.start("Creating configuration files...");
+  try {
+    const configContent = generateConfigFile({
+      strapiUrl: answers.strapiUrl,
+      strapiVersion: answers.strapiVersion,
+      outputDir: answers.outputDir,
+      generateActions: answers.generateActions,
+      generateServices: answers.generateServices
+    });
+    const configPath = path5.join(cwd, "strapi.config.ts");
+    await fs4.writeFile(configPath, configContent, "utf-8");
+    const envPath = path5.join(cwd, ".env");
+    await appendToEnvFile(envPath, {
+      STRAPI_URL: answers.strapiUrl,
+      STRAPI_TOKEN: answers.strapiToken
+    });
+    const outputPath = path5.join(cwd, answers.outputDir);
+    await fs4.mkdir(outputPath, { recursive: true });
+    s.stop("Configuration files created");
+    const installDep = await p.confirm({
+      message: "Install strapi-sdk-js dependency?",
+      initialValue: true
+    });
+    if (p.isCancel(installDep)) {
+      p.cancel("Setup cancelled");
+      process.exit(0);
+    }
+    if (installDep) {
+      s.start("Installing strapi-sdk-js...");
+      try {
+        const installCmd = getInstallCommand(packageManager.name, "strapi-sdk-js");
+        execSync(installCmd, { cwd, stdio: "ignore" });
+        s.stop("Dependency installed");
+      } catch {
+        s.stop("Failed to install dependency");
+        logger.warn(`Please install manually: ${getInstallCommand(packageManager.name, "strapi-sdk-js")}`);
+      }
+    }
+    p.note(
+      [
+        `${pc4.green("v")} Created ${pc4.cyan("strapi.config.ts")}`,
+        `${pc4.green("v")} Updated ${pc4.cyan(".env")} with Strapi credentials`,
+        `${pc4.green("v")} Created output directory ${pc4.cyan(answers.outputDir)}`,
+        "",
+        `Next steps:`,
+        `  1. Run ${pc4.cyan("npx strapi-integrate sync")} to generate types`,
+        `  2. Import types from ${pc4.cyan(answers.outputDir + "/types")}`,
+        `  3. Import services from ${pc4.cyan(answers.outputDir + "/services")}`
+      ].join("\n"),
+      "Setup complete!"
+    );
+    p.outro(pc4.green("Happy coding!"));
+  } catch (error) {
+    s.stop("Failed to create configuration files");
+    logger.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+function generateConfigFile(answers) {
+  return `import { defineConfig } from "strapi-integrate";
+
+export default defineConfig({
+  // Strapi connection
+  url: process.env.STRAPI_URL || "${answers.strapiUrl}",
+  token: process.env.STRAPI_TOKEN,
+
+  // Output configuration
+  output: {
+    path: "${answers.outputDir}",
+    types: "types",
+    services: "services",
+    actions: "actions/strapi",
+    structure: 'by-feature' // or 'by-layer'
+  },
+
+  // Features to generate
+  features: {
+    types: true,
+    services: ${answers.generateServices},
+    actions: ${answers.generateActions},
+  },
+
+  // Strapi version
+  strapiVersion: "${answers.strapiVersion}",
+});
+`;
+}
+async function appendToEnvFile(envPath, variables) {
+  let content = "";
+  try {
+    content = await fs4.readFile(envPath, "utf-8");
+  } catch {
+  }
+  const lines = content.split("\n");
+  const existingKeys = new Set(
+    lines.filter((line) => line.includes("=")).map((line) => line.split("=")[0].trim())
+  );
+  const newLines = [];
+  for (const [key, value] of Object.entries(variables)) {
+    if (!existingKeys.has(key)) {
+      newLines.push(`${key}=${value}`);
+    }
+  }
+  if (newLines.length > 0) {
+    const separator = content.endsWith("\n") || content === "" ? "" : "\n";
+    const newContent = content + separator + newLines.join("\n") + "\n";
+    await fs4.writeFile(envPath, newContent, "utf-8");
+  }
+}
+var BLOCKS_RENDERER_PACKAGE = "@strapi/blocks-react-renderer";
+function schemaHasBlocks(schema) {
+  const fieldsFound = [];
+  const checkAttributes = (typeName, attributes) => {
+    for (const [fieldName, attr] of Object.entries(attributes)) {
+      if (attr.type === "blocks") {
+        fieldsFound.push(`${typeName}.${fieldName}`);
+      }
+    }
+  };
+  for (const collection of schema.collections) {
+    checkAttributes(collection.singularName, collection.attributes);
+  }
+  for (const single of schema.singles) {
+    checkAttributes(single.singularName, single.attributes);
+  }
+  for (const component of schema.components) {
+    checkAttributes(`component:${component.name}`, component.attributes);
+  }
+  return { hasBlocks: fieldsFound.length > 0, fieldsFound };
+}
+function isPackageInstalled(packageName, cwd) {
+  try {
+    const packageJsonPath = path5.join(cwd, "package.json");
+    if (!fs5.existsSync(packageJsonPath)) return false;
+    const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
+    const deps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    return packageName in deps;
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager2(cwd) {
+  if (fs5.existsSync(path5.join(cwd, "bun.lockb"))) return "bun";
+  if (fs5.existsSync(path5.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs5.existsSync(path5.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function installPackage(packageName, cwd) {
+  const pm = detectPackageManager2(cwd);
+  const commands = {
+    npm: `npm install ${packageName}`,
+    yarn: `yarn add ${packageName}`,
+    pnpm: `pnpm add ${packageName}`,
+    bun: `bun add ${packageName}`
+  };
+  execSync(commands[pm], { cwd, stdio: "inherit" });
+}
+function getOrphanedFolders(outputPath, currentStructure) {
+  const orphanedFolders = [];
+  if (currentStructure === "by-feature") {
+    const byLayerFolders = ["types", "services", "actions"];
+    for (const folder of byLayerFolders) {
+      const folderPath = path5.join(outputPath, folder);
+      if (fs5.existsSync(folderPath)) {
+        orphanedFolders.push(folder);
+      }
+    }
+    if (fs5.existsSync(path5.join(outputPath, "client.ts"))) {
+      orphanedFolders.push("client.ts");
+    }
+    if (fs5.existsSync(path5.join(outputPath, "locales.ts"))) {
+      orphanedFolders.push("locales.ts");
+    }
+  } else {
+    const byFeatureFolders = ["collections", "singles", "shared", "components"];
+    for (const folder of byFeatureFolders) {
+      const folderPath = path5.join(outputPath, folder);
+      if (fs5.existsSync(folderPath)) {
+        orphanedFolders.push(folder);
+      }
+    }
+  }
+  return orphanedFolders;
+}
+function cleanOrphanedFiles(outputPath, orphanedItems) {
+  for (const item of orphanedItems) {
+    const itemPath = path5.join(outputPath, item);
+    if (fs5.existsSync(itemPath)) {
+      const stat = fs5.statSync(itemPath);
+      if (stat.isDirectory()) {
+        fs5.rmSync(itemPath, { recursive: true, force: true });
+      } else {
+        fs5.unlinkSync(itemPath);
+      }
+    }
+  }
+}
+async function syncCommand(options) {
+  const cwd = process.cwd();
+  p.intro(pc4.cyan("strapi-integrate sync"));
+  const s = p.spinner();
+  try {
+    s.start("Loading configuration...");
+    let config = await loadConfig(cwd);
+    s.stop("Configuration loaded");
+    s.start("Detecting Strapi version...");
+    const versionResult = await detectStrapiVersion(config.url, config.token);
+    s.stop("Version detection complete");
+    let effectiveVersion = config.strapiVersion;
+    if (versionResult.detected) {
+      if (versionResult.detected !== config.strapiVersion) {
+        if (versionResult.detected === "v5" && config.strapiVersion === "v4") {
+          p.log.warn(
+            pc4.yellow(`Detected Strapi ${pc4.bold("v5")} but config has ${pc4.bold("v4")}. Using v5.`)
+          );
+          effectiveVersion = "v5";
+        } else if (versionResult.detected === "v4" && config.strapiVersion === "v5") {
+          p.log.warn(
+            pc4.yellow(`Detected Strapi ${pc4.bold("v4")} but config has ${pc4.bold("v5")}. Using v4.`)
+          );
+          effectiveVersion = "v4";
+        }
+      } else {
+        p.log.info(`Strapi ${pc4.green(pc4.bold(config.strapiVersion))}`);
+      }
+    } else {
+      p.log.warn(pc4.yellow(`Could not detect Strapi version. Using ${pc4.bold(config.strapiVersion)}`));
+    }
+    config = { ...config, strapiVersion: effectiveVersion };
+    s.start("Fetching schema from Strapi...");
+    const rawSchema = await fetchSchema(config.url, config.token);
+    const schema = parseSchema(rawSchema);
+    s.stop(`Schema fetched: ${schema.collections.length} collections, ${schema.singles.length} singles, ${schema.components.length} components`);
+    let blocksRendererInstalled = isPackageInstalled(BLOCKS_RENDERER_PACKAGE, cwd);
+    const { hasBlocks: hasBlocksFields, fieldsFound: blocksFieldsFound } = schemaHasBlocks(schema);
+    if (hasBlocksFields && !blocksRendererInstalled) {
+      p.log.info(`Blocks fields detected: ${pc4.cyan(blocksFieldsFound.join(", "))}`);
+      const installBlocks = await p.confirm({
+        message: `Install ${pc4.cyan(BLOCKS_RENDERER_PACKAGE)} for proper type support and rendering?`,
+        initialValue: true
+      });
+      if (p.isCancel(installBlocks)) {
+        p.cancel("Sync cancelled");
+        process.exit(0);
+      }
+      if (installBlocks) {
+        s.start(`Installing ${BLOCKS_RENDERER_PACKAGE}...`);
+        try {
+          installPackage(BLOCKS_RENDERER_PACKAGE, cwd);
+          blocksRendererInstalled = true;
+          s.stop(`${BLOCKS_RENDERER_PACKAGE} installed`);
+        } catch (error) {
+          s.stop(`Failed to install ${BLOCKS_RENDERER_PACKAGE}`);
+          logger.warn("You can install it manually later and re-run sync");
+        }
+      } else {
+        p.log.info(pc4.dim(`Skipping ${BLOCKS_RENDERER_PACKAGE}. BlocksContent will be typed as unknown[]`));
+      }
+    }
+    const outputPath = path5.join(cwd, config.output.path);
+    const generatedFiles = [];
+    const generateAll = !options.typesOnly && !options.servicesOnly && !options.actionsOnly;
+    const isByFeature = config.output.structure === "by-feature";
+    const currentStructure = isByFeature ? "by-feature" : "by-layer";
+    if (fs5.existsSync(outputPath)) {
+      const orphanedFolders = getOrphanedFolders(outputPath, currentStructure);
+      if (orphanedFolders.length > 0) {
+        const otherStructure = isByFeature ? "by-layer" : "by-feature";
+        p.log.warn(
+          pc4.yellow(`Found files from previous ${pc4.bold(otherStructure)} structure:`)
+        );
+        p.log.message(pc4.dim(`  ${orphanedFolders.join(", ")}`));
+        let shouldClean = options.clean;
+        if (!shouldClean) {
+          const cleanResponse = await p.confirm({
+            message: `Remove orphaned ${otherStructure} files?`,
+            initialValue: true
+          });
+          if (p.isCancel(cleanResponse)) {
+            p.cancel("Sync cancelled");
+            process.exit(0);
+          }
+          shouldClean = cleanResponse;
+        }
+        if (shouldClean) {
+          s.start("Cleaning orphaned files...");
+          cleanOrphanedFiles(outputPath, orphanedFolders);
+          s.stop(`Removed: ${orphanedFolders.join(", ")}`);
+        } else {
+          p.log.info(pc4.dim("Keeping orphaned files. You can clean them manually or use --clean flag."));
+        }
+      }
+    }
+    if (isByFeature) {
+      s.start("Generating files (by-feature structure)...");
+      const files = await generateByFeature(schema, rawSchema.locales, {
+        outputDir: outputPath,
+        features: {
+          types: config.features.types && (generateAll || Boolean(options.typesOnly)),
+          services: config.features.services && (generateAll || Boolean(options.servicesOnly)),
+          actions: config.features.actions && (generateAll || Boolean(options.actionsOnly))
+        },
+        blocksRendererInstalled,
+        strapiVersion: config.strapiVersion
+      });
+      generatedFiles.push(...files);
+      s.stop(`Generated ${files.length} files`);
+    } else {
+      if (generateAll || options.typesOnly) {
+        if (config.features.types) {
+          s.start("Generating types...");
+          const typesPath = path5.join(outputPath, config.output.types);
+          const files = await generateTypes(schema, {
+            outputDir: typesPath,
+            blocksRendererInstalled,
+            strapiVersion: config.strapiVersion
+          });
+          generatedFiles.push(...files);
+          s.stop(`Generated ${files.length} type files`);
+        }
+      }
+      if (generateAll || options.servicesOnly) {
+        if (config.features.services) {
+          s.start("Generating client...");
+          const clientFiles = await generateClient({ outputDir: outputPath, strapiVersion: config.strapiVersion });
+          generatedFiles.push(...clientFiles);
+          s.stop("Generated client");
+          s.start("Generating locales...");
+          const localesFiles = await generateLocales(rawSchema.locales, { outputDir: outputPath });
+          generatedFiles.push(...localesFiles);
+          if (rawSchema.locales.length > 0) {
+            s.stop(`Generated locales: ${rawSchema.locales.map((l) => l.code).join(", ")}`);
+          } else {
+            s.stop("Generated locales (i18n not enabled in Strapi)");
+          }
+        }
+      }
+      if (generateAll || options.servicesOnly) {
+        if (config.features.services) {
+          s.start("Generating services...");
+          const servicesPath = path5.join(outputPath, config.output.services);
+          const typesImportPath = path5.relative(servicesPath, path5.join(outputPath, config.output.types)).replace(/\\/g, "/") || ".";
+          const files = await generateServices(schema, {
+            outputDir: servicesPath,
+            typesImportPath: typesImportPath.startsWith(".") ? typesImportPath : "./" + typesImportPath,
+            strapiVersion: config.strapiVersion
+          });
+          generatedFiles.push(...files);
+          s.stop(`Generated ${files.length} service files`);
+        }
+      }
+      if (generateAll || options.actionsOnly) {
+        if (config.features.actions) {
+          s.start("Generating Astro actions...");
+          const actionsPath = path5.join(outputPath, config.output.actions);
+          const servicesPath = path5.join(outputPath, config.output.services);
+          const servicesImportPath = path5.relative(actionsPath, servicesPath).replace(/\\/g, "/") || ".";
+          const files = await generateActions(schema, {
+            outputDir: actionsPath,
+            servicesImportPath: servicesImportPath.startsWith(".") ? servicesImportPath : "./" + servicesImportPath,
+            strapiVersion: config.strapiVersion
+          });
+          generatedFiles.push(...files);
+          s.stop(`Generated ${files.length} action files`);
+        }
+      }
+    }
+    p.note(
+      [
+        `Generated ${generatedFiles.length} files in ${pc4.cyan(config.output.path)}`,
+        "",
+        "Files generated:",
+        ...generatedFiles.slice(0, 10).map((f) => `  ${pc4.dim(path5.relative(cwd, f))}`),
+        generatedFiles.length > 10 ? `  ${pc4.dim(`... and ${generatedFiles.length - 10} more`)}` : ""
+      ].filter(Boolean).join("\n"),
+      "Sync complete!"
+    );
+    p.outro(pc4.green("Types and services are ready to use!"));
+  } catch (error) {
+    s.stop("Sync failed");
+    if (error instanceof Error) {
+      logger.error(error.message);
+      if (error.message.includes("Could not find strapi.config")) {
+        logger.info('Run "npx strapi-integrate init" first to set up your project.');
+      }
+    } else {
+      logger.error("An unknown error occurred");
+    }
+    process.exit(1);
+  }
+}
+
+export { detectFramework, detectPackageManager, detectTypeScript, initCommand, logger, syncCommand };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map