@fragments-sdk/cli 0.7.14 → 0.7.16

package/dist/init-DIZ6UNBL.js

@@ -0,0 +1,806 @@
+import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
+import "./chunk-WLXFE6XW.js";
+import "./chunk-7CRC46HV.js";
+import {
+  BRAND
+} from "./chunk-EKLMXTWU.js";
+import "./chunk-Z7EY4VHE.js";
+
+// src/commands/init.ts
+import { writeFile as writeFile2, mkdir, access as access2 } from "fs/promises";
+import { resolve, join as join2, relative, dirname, basename } from "path";
+import { spawn } from "child_process";
+import pc2 from "picocolors";
+import fg from "fast-glob";
+import { input, confirm } from "@inquirer/prompts";
+
+// src/commands/init-framework.ts
+import { readFile, writeFile, access } from "fs/promises";
+import { join } from "path";
+import pc from "picocolors";
+async function detectFramework(projectRoot) {
+  try {
+    const pkgPath = join(projectRoot, "package.json");
+    const pkgContent = await readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgContent);
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    if (allDeps["next"]) {
+      return { framework: "nextjs", detectedBy: "next" };
+    }
+    if (allDeps["@remix-run/react"]) {
+      return { framework: "remix", detectedBy: "@remix-run/react" };
+    }
+    if (allDeps["astro"]) {
+      return { framework: "astro", detectedBy: "astro" };
+    }
+    if (allDeps["vite"]) {
+      return { framework: "vite", detectedBy: "vite" };
+    }
+    return { framework: "unknown", detectedBy: null };
+  } catch {
+    return { framework: "unknown", detectedBy: null };
+  }
+}
+function generateGlobalsSCSS(seeds) {
+  const withClauses = [];
+  if (seeds?.brand) {
+    withClauses.push(`  $fui-brand: ${seeds.brand}`);
+  }
+  if (seeds?.neutral) {
+    withClauses.push(`  $fui-neutral: "${seeds.neutral}"`);
+  }
+  if (seeds?.density) {
+    withClauses.push(`  $fui-density: "${seeds.density}"`);
+  }
+  if (seeds?.radiusStyle) {
+    withClauses.push(`  $fui-radius-style: "${seeds.radiusStyle}"`);
+  }
+  const useStatement = withClauses.length > 0 ? `@use '@fragments-sdk/ui/styles' with (
+${withClauses.join(",\n")}
+);` : `@use '@fragments-sdk/ui/styles';`;
+  return `// Fragments SDK Global Styles
+// Customize seed values to theme the entire design system.
+// See: https://usefragments.com/docs/theming
+${useStatement}
+`;
+}
+function generateProviders() {
+  return `'use client';
+
+import { ThemeProvider } from '@fragments-sdk/ui';
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <ThemeProvider defaultTheme="system" attribute="data-theme">
+      {children}
+    </ThemeProvider>
+  );
+}
+`;
+}
+async function setupNextJS(projectRoot, options) {
+  const result = {
+    framework: "nextjs",
+    filesCreated: [],
+    packagesToInstall: [],
+    configModified: [],
+    warnings: []
+  };
+  try {
+    const pkgContent = await readFile(
+      join(projectRoot, "package.json"),
+      "utf-8"
+    );
+    const pkg = JSON.parse(pkgContent);
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (!allDeps["sass"]) {
+      result.packagesToInstall.push("sass");
+    }
+  } catch {
+  }
+  const nextConfigPaths = [
+    "next.config.ts",
+    "next.config.mjs",
+    "next.config.js"
+  ];
+  for (const configName of nextConfigPaths) {
+    const configPath = join(projectRoot, configName);
+    try {
+      await access(configPath);
+      const content = await readFile(configPath, "utf-8");
+      if (!content.includes("transpilePackages")) {
+        if (content.includes("const nextConfig")) {
+          const updated = content.replace(
+            /const nextConfig\s*=\s*\{/,
+            `const nextConfig = {
+  transpilePackages: ['@fragments-sdk/ui'],`
+          );
+          await writeFile(configPath, updated, "utf-8");
+          result.configModified.push(configName);
+        } else {
+          result.warnings.push(
+            `Could not auto-modify ${configName}. Add transpilePackages: ['@fragments-sdk/ui'] manually.`
+          );
+        }
+      }
+      break;
+    } catch {
+      continue;
+    }
+  }
+  const globalsPath = join(projectRoot, "src", "styles", "globals.scss");
+  try {
+    await access(globalsPath);
+    result.warnings.push(
+      "src/styles/globals.scss already exists. Skipped generation."
+    );
+  } catch {
+    await writeFile(globalsPath, generateGlobalsSCSS(options.seeds), "utf-8");
+    result.filesCreated.push("src/styles/globals.scss");
+  }
+  const providersPath = join(projectRoot, "src", "providers.tsx");
+  try {
+    await access(providersPath);
+    result.warnings.push("src/providers.tsx already exists. Skipped.");
+  } catch {
+    await writeFile(providersPath, generateProviders(), "utf-8");
+    result.filesCreated.push("src/providers.tsx");
+  }
+  return result;
+}
+async function setupVite(projectRoot, options) {
+  const result = {
+    framework: "vite",
+    filesCreated: [],
+    packagesToInstall: [],
+    configModified: [],
+    warnings: []
+  };
+  try {
+    const pkgContent = await readFile(
+      join(projectRoot, "package.json"),
+      "utf-8"
+    );
+    const pkg = JSON.parse(pkgContent);
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (!allDeps["sass"]) {
+      result.packagesToInstall.push("sass");
+    }
+  } catch {
+  }
+  const globalsPath = join(projectRoot, "src", "styles", "globals.scss");
+  try {
+    await access(globalsPath);
+    result.warnings.push(
+      "src/styles/globals.scss already exists. Skipped generation."
+    );
+  } catch {
+    await writeFile(globalsPath, generateGlobalsSCSS(options.seeds), "utf-8");
+    result.filesCreated.push("src/styles/globals.scss");
+  }
+  const providersPath = join(projectRoot, "src", "providers.tsx");
+  try {
+    await access(providersPath);
+    result.warnings.push("src/providers.tsx already exists. Skipped.");
+  } catch {
+    await writeFile(providersPath, generateProviders(), "utf-8");
+    result.filesCreated.push("src/providers.tsx");
+  }
+  return result;
+}
+async function setupRemix(projectRoot, options) {
+  const result = {
+    framework: "remix",
+    filesCreated: [],
+    packagesToInstall: [],
+    configModified: [],
+    warnings: []
+  };
+  result.packagesToInstall.push("sass");
+  const globalsPath = join(projectRoot, "app", "styles", "globals.scss");
+  try {
+    await access(globalsPath);
+    result.warnings.push(
+      "app/styles/globals.scss already exists. Skipped generation."
+    );
+  } catch {
+    await writeFile(globalsPath, generateGlobalsSCSS(options.seeds), "utf-8");
+    result.filesCreated.push("app/styles/globals.scss");
+  }
+  const providersPath = join(projectRoot, "app", "providers.tsx");
+  try {
+    await access(providersPath);
+    result.warnings.push("app/providers.tsx already exists. Skipped.");
+  } catch {
+    await writeFile(providersPath, generateProviders(), "utf-8");
+    result.filesCreated.push("app/providers.tsx");
+  }
+  result.warnings.push(
+    "Add @fragments-sdk/ui to serverDependenciesToBundle in remix.config if using source imports."
+  );
+  return result;
+}
+async function setupAstro(projectRoot, options) {
+  const result = {
+    framework: "astro",
+    filesCreated: [],
+    packagesToInstall: [],
+    configModified: [],
+    warnings: []
+  };
+  result.packagesToInstall.push("sass");
+  const globalsPath = join(projectRoot, "src", "styles", "globals.scss");
+  try {
+    await access(globalsPath);
+    result.warnings.push(
+      "src/styles/globals.scss already exists. Skipped generation."
+    );
+  } catch {
+    await writeFile(globalsPath, generateGlobalsSCSS(options.seeds), "utf-8");
+    result.filesCreated.push("src/styles/globals.scss");
+  }
+  return result;
+}
+async function setupFramework(options) {
+  const { projectRoot } = options;
+  let framework = options.framework;
+  if (!framework || framework === "unknown") {
+    const detection = await detectFramework(projectRoot);
+    framework = detection.framework;
+    if (detection.detectedBy) {
+      console.log(
+        pc.green(`  Detected ${frameworkLabel(framework)}`) + pc.dim(` (via ${detection.detectedBy})`)
+      );
+    }
+  } else {
+    console.log(pc.green(`  Framework: ${frameworkLabel(framework)}`));
+  }
+  switch (framework) {
+    case "nextjs":
+      return setupNextJS(projectRoot, options);
+    case "vite":
+      return setupVite(projectRoot, options);
+    case "remix":
+      return setupRemix(projectRoot, options);
+    case "astro":
+      return setupAstro(projectRoot, options);
+    default:
+      return {
+        framework: "unknown",
+        filesCreated: [],
+        packagesToInstall: ["sass"],
+        configModified: [],
+        warnings: [
+          "Could not detect framework. Install sass and import @fragments-sdk/ui/styles manually."
+        ]
+      };
+  }
+}
+function frameworkLabel(framework) {
+  switch (framework) {
+    case "nextjs":
+      return "Next.js";
+    case "vite":
+      return "Vite";
+    case "remix":
+      return "Remix";
+    case "astro":
+      return "Astro";
+    default:
+      return "Unknown";
+  }
+}
+
+// src/commands/init.ts
+async function detectProject(projectRoot) {
+  console.log(pc2.dim("\nScanning project...\n"));
+  const configPath = join2(projectRoot, BRAND.configFile);
+  const legacyConfigPath = join2(projectRoot, BRAND.legacyConfigFile);
+  let hasConfig = false;
+  let foundConfigPath = null;
+  try {
+    await access2(configPath);
+    hasConfig = true;
+    foundConfigPath = configPath;
+  } catch {
+    try {
+      await access2(legacyConfigPath);
+      hasConfig = true;
+      foundConfigPath = legacyConfigPath;
+    } catch {
+    }
+  }
+  const storyFiles = await fg(
+    ["**/*.stories.tsx", "**/*.stories.ts", "**/*.stories.jsx", "**/*.stories.js"],
+    {
+      cwd: projectRoot,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.storybook/**"]
+    }
+  );
+  const componentFiles = await fg(
+    ["**/components/**/*.tsx", "**/Components/**/*.tsx", "src/**/*.tsx"],
+    {
+      cwd: projectRoot,
+      ignore: [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/*.stories.*",
+        "**/*.fragment.*",
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/*.d.ts",
+        "**/index.tsx"
+        // Skip barrel files
+      ]
+    }
+  );
+  const nonComponentPatterns = /\.(styles|utils|helpers|constants|types|hooks|context|config|mock|fixture)\./i;
+  const nonComponentNames = /^(index|types|utils|helpers|constants|hooks|providers|layout|use[A-Z])/;
+  const likelyComponents = componentFiles.filter((f) => {
+    const fileName = f.split("/").pop() || "";
+    const baseName = fileName.replace(/\.tsx$/, "");
+    return !nonComponentPatterns.test(fileName) && !nonComponentNames.test(baseName);
+  });
+  let suggestedComponentPath = "src/components";
+  if (likelyComponents.length > 0) {
+    const firstComponent = likelyComponents[0];
+    const parts = firstComponent.split("/");
+    const componentsIndex = parts.findIndex(
+      (p) => p.toLowerCase() === "components"
+    );
+    if (componentsIndex !== -1) {
+      suggestedComponentPath = parts.slice(0, componentsIndex + 1).join("/");
+    }
+  }
+  return {
+    storyFiles,
+    componentFiles: likelyComponents,
+    hasConfig,
+    configPath: foundConfigPath,
+    suggestedComponentPath
+  };
+}
+function generateConfig(options) {
+  const includeStr = options.includePaths.map((p) => `    '${p}'`).join(",\n");
+  const componentStr = options.componentPaths.map((p) => `    '${p}'`).join(",\n");
+  return `import type { FragmentsConfig } from '@fragments-sdk/cli';
+
+const config: FragmentsConfig = {
+  // Glob patterns for finding fragment/story files
+  include: [
+${includeStr}
+  ],
+
+  // Glob patterns to exclude
+  exclude: ['**/node_modules/**'],
+
+  // Glob patterns for finding component files (for auto-documentation)
+  components: [
+${componentStr}
+  ],
+
+  // Framework (react, vue, svelte)
+  framework: '${options.framework}',
+};
+
+export default config;
+`;
+}
+function generateExampleComponent() {
+  return `import React from 'react';
+
+export interface ButtonProps {
+  /** Button label */
+  children: React.ReactNode;
+  /** Visual style variant */
+  variant?: 'primary' | 'secondary' | 'ghost';
+  /** Button size */
+  size?: 'sm' | 'md' | 'lg';
+  /** Disabled state */
+  disabled?: boolean;
+  /** Click handler */
+  onClick?: () => void;
+}
+
+export function Button({
+  children,
+  variant = 'primary',
+  size = 'md',
+  disabled = false,
+  onClick,
+}: ButtonProps) {
+  const baseStyles = 'inline-flex items-center justify-center font-medium rounded-md transition-colors';
+
+  const variantStyles = {
+    primary: 'bg-blue-600 text-white hover:bg-blue-700',
+    secondary: 'bg-gray-200 text-gray-900 hover:bg-gray-300',
+    ghost: 'bg-transparent text-gray-700 hover:bg-gray-100',
+  };
+
+  const sizeStyles = {
+    sm: 'px-3 py-1.5 text-sm',
+    md: 'px-4 py-2 text-base',
+    lg: 'px-6 py-3 text-lg',
+  };
+
+  return (
+    <button
+      className={\`\${baseStyles} \${variantStyles[variant]} \${sizeStyles[size]}\`}
+      disabled={disabled}
+      onClick={onClick}
+    >
+      {children}
+    </button>
+  );
+}
+`;
+}
+function generateExampleFragment() {
+  return `import React from 'react';
+import { defineFragment } from '@fragments-sdk/cli/core';
+import { Button } from './Button';
+
+export default defineFragment({
+  component: Button,
+
+  meta: {
+    name: 'Button',
+    description: 'Interactive button for triggering actions',
+    category: 'Actions',
+    status: 'stable',
+  },
+
+  usage: {
+    when: [
+      'Triggering an action (save, submit, delete)',
+      'Form submission',
+      'Opening dialogs or menus',
+    ],
+    whenNot: [
+      'Simple navigation (use Link)',
+      'Toggling state (use Switch)',
+    ],
+    guidelines: [
+      'Use Primary for the main action in a context',
+      'Only one Primary button per section',
+    ],
+  },
+
+  props: {
+    children: {
+      type: 'node',
+      required: true,
+      description: 'Button label content',
+    },
+    variant: {
+      type: 'enum',
+      values: ['primary', 'secondary', 'ghost'],
+      default: 'primary',
+      description: 'Visual style variant',
+    },
+    size: {
+      type: 'enum',
+      values: ['sm', 'md', 'lg'],
+      default: 'md',
+      description: 'Button size',
+    },
+  },
+
+  variants: [
+    {
+      name: 'Primary',
+      description: 'Default action button',
+      code: \`import { Button } from './Button';
+
+<Button variant="primary">Save Changes</Button>\`,
+      render: () => <Button variant="primary">Save Changes</Button>,
+    },
+    {
+      name: 'Secondary',
+      description: 'Less prominent action',
+      code: \`import { Button } from './Button';
+
+<Button variant="secondary">Cancel</Button>\`,
+      render: () => <Button variant="secondary">Cancel</Button>,
+    },
+    {
+      name: 'Ghost',
+      description: 'Minimal visual weight',
+      code: \`import { Button } from './Button';
+
+<Button variant="ghost">Learn More</Button>\`,
+      render: () => <Button variant="ghost">Learn More</Button>,
+    },
+    {
+      name: 'Sizes',
+      description: 'Available size options',
+      code: \`import { Button } from './Button';
+
+<>
+  <Button size="sm">Small</Button>
+  <Button size="md">Medium</Button>
+  <Button size="lg">Large</Button>
+</>\`,
+      render: () => (
+        <>
+          <Button size="sm">Small</Button>
+          <Button size="md">Medium</Button>
+          <Button size="lg">Large</Button>
+        </>
+      ),
+    },
+  ],
+});
+`;
+}
+function toPascalCase(str) {
+  return str.replace(/[-_.](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
+}
+function generateFragmentStub(componentName, importPath) {
+  return `import React from 'react';
+import { defineFragment } from '@fragments-sdk/cli/core';
+import { ${componentName} } from '${importPath}';
+
+export default defineFragment({
+  component: ${componentName},
+
+  meta: {
+    name: '${componentName}',
+    description: '${componentName} component',
+    category: 'general',
+    status: 'beta',
+  },
+
+  usage: {
+    when: ['TODO: describe when to use ${componentName}'],
+    whenNot: ['TODO: describe when not to use ${componentName}'],
+  },
+
+  props: {},
+
+  variants: [
+    {
+      name: 'Default',
+      description: 'Default ${componentName}',
+      code: \`<${componentName} />\`,
+      render: () => <${componentName} />,
+    },
+  ],
+});
+`;
+}
+function startDevServer(projectRoot) {
+  console.log(pc2.dim("\nStarting development server...\n"));
+  const isWindows = process.platform === "win32";
+  const cmd = isWindows ? "npx.cmd" : "npx";
+  const child = spawn(cmd, [BRAND.cliCommand, "dev"], {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  child.on("error", (err) => {
+    console.error(pc2.red("Failed to start dev server:"), err.message);
+  });
+}
+async function init(options = {}) {
+  const projectRoot = resolve(options.projectRoot || process.cwd());
+  const errors = [];
+  console.log(pc2.cyan(`
+\u2728 Welcome to ${BRAND.name}!
+`));
+  const detection = await detectProject(projectRoot);
+  if (detection.hasConfig && !options.force) {
+    console.log(pc2.yellow(`\u26A0 Config already exists: ${BRAND.configFile}`));
+    if (!options.yes) {
+      const overwrite = await confirm({
+        message: "Do you want to reinitialize? (This will overwrite your config)",
+        default: false
+      });
+      if (!overwrite) {
+        console.log(pc2.dim(`
+Keeping existing configuration. Run \`${BRAND.cliCommand} dev\` to start.
+`));
+        return {
+          success: true,
+          scenario: "stories",
+          storiesFound: detection.storyFiles.length,
+          componentsFound: detection.componentFiles.length,
+          errors: []
+        };
+      }
+    }
+  }
+  let scenario;
+  if (detection.storyFiles.length > 0) {
+    scenario = "stories";
+    console.log(pc2.green(`\u2713 Found ${detection.storyFiles.length} Storybook story file(s)`));
+    console.log(pc2.dim(`  ${detection.storyFiles.slice(0, 3).join("\n  ")}`));
+    if (detection.storyFiles.length > 3) {
+      console.log(pc2.dim(`  ... and ${detection.storyFiles.length - 3} more`));
+    }
+    console.log();
+    console.log(
+      pc2.cyan("Great news! ") + "Fragments can load your existing stories automatically."
+    );
+  } else if (detection.componentFiles.length > 0) {
+    scenario = "components";
+    console.log(pc2.green(`\u2713 Found ${detection.componentFiles.length} component file(s)`));
+    console.log(pc2.dim(`  ${detection.componentFiles.slice(0, 3).join("\n  ")}`));
+    if (detection.componentFiles.length > 3) {
+      console.log(pc2.dim(`  ... and ${detection.componentFiles.length - 3} more`));
+    }
+    console.log();
+    console.log(
+      pc2.cyan("No stories found, but that's fine! ") + "Fragments can auto-generate documentation from your TypeScript."
+    );
+  } else {
+    scenario = "fresh";
+    console.log(pc2.yellow("No components or stories found."));
+    console.log();
+    console.log(pc2.cyan("Let's create your first fragment!"));
+  }
+  console.log();
+  let componentPath = detection.suggestedComponentPath;
+  let runScan = scenario === "components";
+  let createExample = scenario === "fresh";
+  let startServer = true;
+  if (!options.yes) {
+    componentPath = await input({
+      message: "Where are your components located?",
+      default: detection.suggestedComponentPath
+    });
+    if (scenario === "components") {
+      runScan = await confirm({
+        message: "Auto-generate documentation from TypeScript?",
+        default: true
+      });
+    } else {
+      createExample = await confirm({
+        message: "Create an example Button component to get started?",
+        default: true
+      });
+    }
+    startServer = await confirm({
+      message: "Start the viewer now?",
+      default: true
+    });
+  }
+  console.log(pc2.dim("\nCreating configuration...\n"));
+  const includePaths = [
+    `${componentPath}/**/*.fragment.tsx`
+  ];
+  if (scenario === "stories") {
+    includePaths.push(`${componentPath}/**/*.stories.tsx`);
+    includePaths.push(`${componentPath}/**/*.stories.ts`);
+  }
+  const configPath = join2(projectRoot, BRAND.configFile);
+  const configContent = generateConfig({
+    includePaths,
+    componentPaths: [`${componentPath}/**/*.tsx`],
+    framework: "react"
+  });
+  try {
+    await writeFile2(configPath, configContent, "utf-8");
+    console.log(pc2.green(`\u2713 Created ${BRAND.configFile}`));
+  } catch (e) {
+    errors.push(`Failed to create config: ${e}`);
+  }
+  if (scenario === "fresh" && createExample) {
+    const exampleDir = join2(projectRoot, componentPath, "Button");
+    try {
+      await mkdir(exampleDir, { recursive: true });
+      await writeFile2(
+        join2(exampleDir, "Button.tsx"),
+        generateExampleComponent(),
+        "utf-8"
+      );
+      console.log(
+        pc2.green(`\u2713 Created ${relative(projectRoot, join2(exampleDir, "Button.tsx"))}`)
+      );
+      await writeFile2(
+        join2(exampleDir, "Button.fragment.tsx"),
+        generateExampleFragment(),
+        "utf-8"
+      );
+      console.log(
+        pc2.green(
+          `\u2713 Created ${relative(projectRoot, join2(exampleDir, "Button.fragment.tsx"))}`
+        )
+      );
+    } catch (e) {
+      errors.push(`Failed to create example component: ${e}`);
+    }
+  }
+  if (scenario === "components" && runScan) {
+    let stubsCreated = 0;
+    for (const compFile of detection.componentFiles) {
+      const absPath = join2(projectRoot, compFile);
+      const dir = dirname(absPath);
+      const fileName = basename(compFile, ".tsx");
+      const componentName = toPascalCase(fileName);
+      const fragmentPath = join2(dir, `${fileName}.fragment.tsx`);
+      try {
+        await access2(fragmentPath);
+        continue;
+      } catch {
+      }
+      try {
+        const stub = generateFragmentStub(componentName, `./${fileName}`);
+        await writeFile2(fragmentPath, stub, "utf-8");
+        stubsCreated++;
+      } catch {
+      }
+    }
+    if (stubsCreated > 0) {
+      console.log(pc2.green(`\u2713 Generated ${stubsCreated} fragment stub(s)`));
+    }
+    console.log(pc2.dim("\nGenerating documentation from source code...\n"));
+    try {
+      const { scan } = await import("./scan-X3DI2X5G.js");
+      await scan({
+        config: configPath,
+        verbose: false
+      });
+    } catch (e) {
+      console.log(
+        pc2.yellow(`Note: Auto-documentation will run when you start the dev server.`)
+      );
+    }
+  }
+  console.log(pc2.dim("\nConfiguring framework integration...\n"));
+  const frameworkOverride = options.framework;
+  const frameworkResult = await setupFramework({
+    projectRoot,
+    framework: frameworkOverride
+  });
+  if (frameworkResult.filesCreated.length > 0) {
+    for (const file of frameworkResult.filesCreated) {
+      console.log(pc2.green(`\u2713 Created ${file}`));
+    }
+  }
+  if (frameworkResult.configModified.length > 0) {
+    for (const file of frameworkResult.configModified) {
+      console.log(pc2.green(`\u2713 Updated ${file}`));
+    }
+  }
+  if (frameworkResult.packagesToInstall.length > 0) {
+    const pkgs = frameworkResult.packagesToInstall.join(" ");
+    console.log(
+      pc2.yellow(`
+\u26A0 Install required dependencies: `) + pc2.bold(`pnpm add -D ${pkgs}`)
+    );
+  }
+  for (const warning of frameworkResult.warnings) {
+    console.log(pc2.yellow(`  Note: ${warning}`));
+  }
+  if (errors.length === 0) {
+    console.log(pc2.green("\n\u2713 Setup complete!\n"));
+    if (startServer) {
+      const serverMessage = scenario === "stories" ? `Your ${detection.storyFiles.length} stories are loading...` : scenario === "components" ? `Your ${detection.componentFiles.length} components are being documented...` : `Your first component is ready!`;
+      console.log(pc2.cyan(serverMessage));
+      startDevServer(projectRoot);
+    } else {
+      console.log(pc2.cyan("Next steps:"));
+      console.log(`  1. Run ${pc2.bold(`${BRAND.cliCommand} dev`)} to start the viewer`);
+      if (scenario === "fresh") {
+        console.log(`  2. Edit ${pc2.bold(`${componentPath}/Button/Button.fragment.tsx`)}`);
+      }
+      console.log();
+    }
+  }
+  return {
+    success: errors.length === 0,
+    configPath: errors.length === 0 ? configPath : void 0,
+    scenario,
+    storiesFound: detection.storyFiles.length,
+    componentsFound: detection.componentFiles.length,
+    errors
+  };
+}
+export {
+  init
+};
+//# sourceMappingURL=init-DIZ6UNBL.js.map