rollup.config.ts

/**
 * Rollup build configuration for library, CLI entrypoint, and bundled types.
 * Externalizes production dependencies; emits ESM outputs; best-effort doc copy.
 * @module
 */
import aliasPlugin, { type Alias } from '@rollup/plugin-alias';
import commonjsPlugin from '@rollup/plugin-commonjs';
import jsonPlugin from '@rollup/plugin-json';
import { nodeResolve } from '@rollup/plugin-node-resolve';
import terserPlugin from '@rollup/plugin-terser';
import typescriptPlugin from '@rollup/plugin-typescript';
import fs from 'fs-extra';
import path from 'node:path';
import { builtinModules } from 'node:module';
import { fileURLToPath } from 'node:url';
import type {
  InputOptions,
  OutputOptions,
  Plugin,
  RollupOptions,
} from 'rollup';
import dtsPlugin from 'rollup-plugin-dts';
import { createRequire } from 'node:module';

const outputPath = 'dist';

// Path alias @ -> <abs>/src
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const srcAbs = path.resolve(__dirname, 'src');
const aliases: Alias[] = [{ find: '@', replacement: srcAbs }];
const alias = aliasPlugin({ entries: aliases });

// Externalize all production dependencies to avoid bundling issues (assets, singletons, __filename)
// and to keep the distribution size small (relying on node_modules).
const pkg = JSON.parse(
  fs.readFileSync(path.resolve(__dirname, 'package.json'), 'utf8'),
) as { dependencies?: Record<string, string> };

const externalPkgs = new Set([
  ...(pkg.dependencies ? Object.keys(pkg.dependencies) : []),
  // Explicit additions if needed (e.g. peer deps or optionals not in dependencies)
  'clipboardy',
  'fs-extra',
  'typescript',
]);

// Treat Node built-ins and node: specifiers as external.
const nodeExternals = new Set([
  ...builtinModules,
  ...builtinModules.map((m) => `node:${m}`),
]);

const copyDocsPlugin = (dest: string): Plugin => {
  return {
    name: 'stan-copy-docs',
    async writeBundle() {
      const fromSystem = path.resolve(__dirname, '.stan', 'system');
      const candidates = [
        {
          src: path.join(fromSystem, 'stan.system.md'),
          dest: path.join(dest, 'stan.system.md'),
        },
      ];
      try {
        await fs.ensureDir(dest);
        for (const c of candidates) {
          if (await fs.pathExists(c.src)) await fs.copyFile(c.src, c.dest);
        }
      } catch {
        // best-effort
      }
    },
  };
};
const makePlugins = (minify: boolean, extras: Plugin[] = []): Plugin[] => {
  const base: Plugin[] = [
    alias,
    nodeResolve({ exportConditions: ['node', 'module', 'default'] }),
    commonjsPlugin(),
    jsonPlugin(),
    typescriptPlugin(),
    ...extras,
  ];
  return minify
    ? [...base, terserPlugin({ format: { comments: false } })]
    : base;
};

const commonInputOptions = (
  minify: boolean,
  extras: Plugin[] = [],
): InputOptions => ({
  plugins: makePlugins(minify, extras),
  onwarn(warning, defaultHandler) {
    // CI build guard: fail on new circular dependencies introduced in this package.
    // Allow cycles originating from node_modules (e.g., zod), but treat project cycles as errors.
    if (warning.code === 'CIRCULAR_DEPENDENCY') {
      const msg = String((warning as { message?: string }).message ?? '');
      const ids =
        ((warning as unknown as { ids?: string[] }).ids as
          | string[]
          | undefined) ?? [];
      const fromNodeModules =
        (Array.isArray(ids) && ids.some((p) => p.includes('node_modules'))) ||
        /node_modules/.test(msg);
      if (!fromNodeModules) {
        // Treat as a hard error to surface regressions early in CI.
        throw new Error(`Circular dependency detected: ${msg}`);
      }
    }
    defaultHandler(warning);
  },
  external: (id) =>
    nodeExternals.has(id) ||
    externalPkgs.has(id) ||
    // also treat deep subpath imports as external (e.g., clipboardy/fallbacks/...)
    Array.from(externalPkgs).some((p) => id === p || id.startsWith(`${p}/`)),
});

/**
 * Rollup options to build the public library entrypoint (`src/index.ts`) into an
 * ESM-only output folder.
 *
 * @param dest - Destination directory where Rollup should write the library output.
 * @returns Rollup configuration for the library build.
 */
export const buildLibrary = (dest: string): RollupOptions => ({
  input: 'src/index.ts',
  output: [{ dir: dest, format: 'esm', sourcemap: false }],
  ...commonInputOptions(
    true,
    // Copy docs once from library config
    [copyDocsPlugin(dest)],
  ),
});

const discoverCliEntries = (): string[] => {
  const candidates = [
    'src/cli/bin/stan.ts', // preferred: single bootstrap
    'src/cli/stan.ts', // legacy fallback (should not exist post‑cleanup)
    'src/cli/index.ts', // last resort (library factory only)
  ];
  const found = candidates.filter((p) => fs.existsSync(p));
  // Prefer a single CLI entry to avoid duplicate bundles.
  return found.length ? [found[0]!] : [];
};

/**
 * Rollup options to build the CLI entrypoint (preferring `src/cli/bin/stan.ts`)
 * into a Node-executable ESM bundle with a shebang banner.
 *
 * @param dest - Destination directory where Rollup should write the CLI output.
 * @returns Rollup configuration for the CLI build.
 */
export const buildCli = (dest: string): RollupOptions => ({
  input: discoverCliEntries(),
  output: [
    {
      dir: `${dest}/cli`,
      format: 'esm',
      sourcemap: false,
      banner: '#!/usr/bin/env node',
    },
  ],
  ...commonInputOptions(false),
});

/**
 * Rollup options to bundle TypeScript declaration files for the library
 * entrypoint (`src/index.ts`).
 *
 * @param dest - Destination directory where Rollup should write the generated types.
 * @returns Rollup configuration for the declaration build.
 */
export const buildTypes = (dest: string): RollupOptions => ({
  input: 'src/index.ts',
  output: [{ dir: `${dest}/types`, format: 'esm' }],
  // Ensure alias resolution works during type bundling to avoid unresolved "@/..." warnings.
  plugins: [alias, dtsPlugin()],
});

/**
 * Default Rollup configuration (library build, CLI build, and bundled types).
 */
export default [
  buildLibrary(outputPath),
  buildCli(outputPath),
  buildTypes(outputPath),
];