rootless-config 1.0.2 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootless-config",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Store project config files outside the project root, auto-deploy them where tools expect them.",
   "type": "module",
   "bin": {

package/src/cli/commands/init.js

@@ -2,14 +2,15 @@
 
 import path from 'node:path'
 import { createLogger } from '../../utils/logger.js'
-import { fileExists, ensureDir, atomicWrite, writeJsonFile } from '../../utils/fsUtils.js'
+import { fileExists, ensureDir, atomicWrite, writeJsonFile, readJsonFile } from '../../utils/fsUtils.js'
 import { confirm } from '../../utils/prompt.js'
 import { getLibraryVersion } from '../../core/versionCheck.js'
+import { addPrepareHook } from '../../core/scriptPatcher.js'
 
 const DIRS = ['configs', 'env', 'assets']
 
 const DEFAULT_CONFIG = {
-  mode: 'proxy',
+  mode: 'clean',
   experimental: {
     virtualFS: false,
     capsule: false,
@@ -28,7 +29,7 @@ export default {
     const containerPath = path.join(projectRoot, '.root')
 
     if (await fileExists(containerPath)) {
-      const proceed = await confirm('.root already exists. Reinitialize?')
+      const proceed = args.yes || await confirm('.root already exists. Reinitialize?')
       if (!proceed) {
         logger.info('Init cancelled')
         return
@@ -46,7 +47,14 @@ export default {
     await atomicWrite(path.join(containerPath, 'rootless.version'), getLibraryVersion())
     logger.success('Created: .root/rootless.version')
 
+    // Add "prepare": "rootless prepare --yes" so npm install auto-triggers generation
+    const pkgPath = path.join(projectRoot, 'package.json')
+    if (await fileExists(pkgPath)) {
+      const hookValue = await addPrepareHook(projectRoot)
+      if (hookValue) logger.success(`Added prepare hook to package.json: "${hookValue}"`)
+    }
+
     logger.info('Done. Move your config files into .root/configs/, .root/env/, or .root/assets/')
-    logger.info('Then run: rootless prepare')
+    logger.info('Then run: rootless migrate  (auto-moves files + patches package.json scripts)')
   },
 }

package/src/cli/commands/migrate.js

@@ -1,23 +1,39 @@
 /*-------- rootless migrate — moves existing root configs into .root container --------*/
 
 import path from 'node:path'
-import { readdir } from 'node:fs/promises'
+import { readdir, unlink, readFile } from 'node:fs/promises'
 import { createLogger } from '../../utils/logger.js'
-import { fileExists, ensureDir, atomicWrite } from '../../utils/fsUtils.js'
-import { readFile } from 'node:fs/promises'
+import { fileExists, ensureDir, atomicWrite, readJsonFile } from '../../utils/fsUtils.js'
 import { confirm } from '../../utils/prompt.js'
+import { patchPackageScripts } from '../../core/scriptPatcher.js'
 
-const CONFIG_PATTERN = /\.(config|rc)\.(js|ts|mjs|cjs|json)$|\.eslintrc$|\.babelrc$/
+const CONFIG_PATTERN = /\.(config|rc)\.(js|ts|mjs|cjs|json)$|\.eslintrc$|\.babelrc$|tsconfig.*\.json$/
 const ENV_PATTERN = /^\.env/
+// Dot-files and special files that must be in root — auto-detected
+const DOTFILE_PATTERN = /^\.(nvmrc|node-version|npmrc|yarnrc|yarnrc\.yml|pnpmfile\.cjs|editorconfig|gitignore|gitattributes|dockerignore|browserslistrc|prettierignore|eslintignore|stylelintignore|czrc|cz\.json|commitlintrc.*|lintstagedrc.*|releaserc.*)$|^(Dockerfile.*|Procfile|browserslist)$/
 
 async function findMigratableFiles(projectRoot) {
   const entries = await readdir(projectRoot, { withFileTypes: true })
   return entries
-    .filter(e => e.isFile() && (CONFIG_PATTERN.test(e.name) || ENV_PATTERN.test(e.name)))
+    .filter(e => e.isFile() && (
+      CONFIG_PATTERN.test(e.name) ||
+      ENV_PATTERN.test(e.name) ||
+      DOTFILE_PATTERN.test(e.name)
+    ))
+    .filter(e => e.name !== 'package.json')
     .map(e => e.name)
     .sort()
 }
 
+async function getProjectMode(containerPath) {
+  try {
+    const cfg = await readJsonFile(path.join(containerPath, 'rootless.config.json'))
+    return cfg.mode ?? 'clean'
+  } catch {
+    return 'clean'
+  }
+}
+
 export default {
   name: 'migrate',
   description: 'Move existing config files from project root into .root container',
@@ -26,6 +42,8 @@ export default {
     const logger = createLogger({ verbose: args.verbose ?? false })
     const projectRoot = args.cwd ? path.resolve(args.cwd) : process.cwd()
     const containerPath = path.join(projectRoot, '.root')
+    const mode = await getProjectMode(containerPath)
+    const isCleanMode = mode === 'clean'
 
     const candidates = await findMigratableFiles(projectRoot)
     if (candidates.length === 0) {
@@ -35,6 +53,12 @@ export default {
 
     logger.info(`Found ${candidates.length} migratable files:\n  ${candidates.join('\n  ')}`)
 
+    if (isCleanMode) {
+      logger.info('Mode: clean — originals will be DELETED from root, package.json scripts will be patched')
+    } else {
+      logger.info('Mode: proxy — originals will be replaced with re-export stubs')
+    }
+
     const proceed = args.yes || await confirm('Move these files to .root/?')
     if (!proceed) {
       logger.info('Migration cancelled')
@@ -50,13 +74,31 @@ export default {
       const content = await readFile(src, 'utf8')
       await atomicWrite(path.join(destDir, name), content)
 
-      const rel = path.relative(path.dirname(src), path.join(containerPath, isEnv ? 'env' : 'configs', name)).replace(/\\/g, '/')
-      const relPath = rel.startsWith('.') ? rel : `./${rel}`
-      await atomicWrite(src, `export { default } from "${relPath}"\n`)
-
-      logger.success(`Migrated: ${name}`)
+      if (isCleanMode) {
+        // Clean mode: delete original — no proxy file in root
+        await unlink(src)
+        logger.success(`Moved to .root/${isEnv ? 'env' : 'configs'}/${name} (deleted from root)`)
+      } else {
+        // Proxy mode: replace original with re-export stub
+        const rel = path.relative(path.dirname(src), path.join(destDir, name)).replace(/\\/g, '/')
+        const relPath = rel.startsWith('.') ? rel : `./${rel}`
+        await atomicWrite(src, `export { default } from "${relPath}"\n`)
+        logger.success(`Migrated: ${name}`)
+      }
     }
 
-    logger.info('Run: rootless prepare to regenerate')
+    if (isCleanMode) {
+      // Patch package.json scripts to point to .root/configs/
+      const configsDir = path.join(containerPath, 'configs')
+      const patched = await patchPackageScripts(projectRoot, configsDir, logger)
+      if (patched) {
+        logger.success('package.json scripts patched — tools will now use configs from .root/configs/')
+      } else {
+        logger.info('No npm scripts needed patching (or none found)')
+      }
+      logger.info('Run: rootless prepare  (copies .env files to root)')
+    } else {
+      logger.info('Run: rootless prepare to regenerate')
+    }
   },
 }

package/src/core/cliWrapper.js

@@ -13,6 +13,7 @@ import { readManifest, removeFromManifest } from './generatedManifest.js'
 import { removeHash } from './fileHashCache.js'
 import { resolveProjectRoot, resolveContainerPath, setContainerOverride } from './pathResolver.js'
 import { fileExists, removeFile } from '../utils/fsUtils.js'
+import { patchPackageScripts, isRootRequired } from './scriptPatcher.js'
 import { ValidationError } from '../types/errors.js'
 
 async function loadConfig(containerPath) {
@@ -49,9 +50,64 @@ async function preparePipeline(options = {}) {
   const containerPath = await resolveContainerPath()
   const config = ctx.container.manifest ?? {}
   const graph = await getGraph(config)
+  const isCleanMode = (config.mode ?? 'clean') === 'clean'
 
-  const entries = await buildGenerationEntries(containerPath, graph, ctx)
   const projectRoot = await resolveProjectRoot()
+
+  if (isCleanMode) {
+    const envDir     = path.join(containerPath, 'env')
+    const configsDir = path.join(containerPath, 'configs')
+    const assetsDir  = path.join(containerPath, 'assets')
+
+    const copyEntries = []
+
+    // 1. env/* — all .env files always go to root
+    if (await fileExists(envDir)) {
+      for (const f of await readdir(envDir, { withFileTypes: true })) {
+        if (!f.isFile()) continue
+        const absPath = path.join(envDir, f.name)
+        const plugin = ctx.pluginRegistry.resolve(absPath)[0] ?? null
+        copyEntries.push({ source: absPath, target: path.join(projectRoot, f.name), mode: 'copy', plugin })
+      }
+    }
+
+    // 2. assets/* — favicon, robots.txt, manifests etc. always go to root
+    if (await fileExists(assetsDir)) {
+      for (const f of await readdir(assetsDir, { withFileTypes: true })) {
+        if (!f.isFile()) continue
+        const absPath = path.join(assetsDir, f.name)
+        const plugin = ctx.pluginRegistry.resolve(absPath)[0] ?? null
+        copyEntries.push({ source: absPath, target: path.join(projectRoot, f.name), mode: 'copy', plugin })
+      }
+    }
+
+    // 3. configs/* — split by whether the file can be redirected via CLI flags
+    //    isRootRequired(name) = true  → copy to root (tool can't be redirected: .nvmrc, .editorconfig, etc.)
+    //    isRootRequired(name) = false → skip copy, only patch scripts below
+    if (await fileExists(configsDir)) {
+      for (const f of await readdir(configsDir, { withFileTypes: true })) {
+        if (!f.isFile()) continue
+        if (isRootRequired(f.name)) {
+          const absPath = path.join(configsDir, f.name)
+          const plugin = ctx.pluginRegistry.resolve(absPath)[0] ?? null
+          copyEntries.push({ source: absPath, target: path.join(projectRoot, f.name), mode: 'copy', plugin })
+        }
+      }
+    }
+
+    const results = await generateFiles(copyEntries, options, ctx.logger)
+
+    // 4. Patch package.json scripts for all patchable tool configs (vite, eslint, jest, pm2, etc.)
+    const patched = await patchPackageScripts(projectRoot, configsDir, ctx.logger)
+    if (patched) ctx.logger.success('package.json scripts patched with --config flags')
+    else ctx.logger.debug('No script patching needed')
+
+    await ctx.dispose()
+    return results
+  }
+
+  // Proxy mode: generate proxy/copy for every file in .root/
+  const entries = await buildGenerationEntries(containerPath, graph, ctx)
   const mapped = entries.map(e => ({
     ...e,
     target: path.join(projectRoot, path.basename(e.source)),

package/src/core/scriptPatcher.js

@@ -0,0 +1,235 @@
+/*-------- Patches package.json scripts to use --config flags pointing to .root/ --------*/
+
+import path from 'node:path'
+import { readdir } from 'node:fs/promises'
+import { readJsonFile, writeJsonFile, fileExists } from '../utils/fsUtils.js'
+
+/**
+ * Tools that support a --config (or similar) flag.
+ * These files can be REMOVED from root — scripts get patched instead.
+ * Ordered by specificity (longer command first to avoid partial matches).
+ */
+const TOOL_CONFIGS = [
+  { cmd: 'vite build',       flag: '--config',  files: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'] },
+  { cmd: 'vite preview',     flag: '--config',  files: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'] },
+  { cmd: 'vite',             flag: '--config',  files: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'] },
+  { cmd: 'vitest run',       flag: '--config',  files: ['vitest.config.js', 'vitest.config.ts', 'vitest.config.mjs'] },
+  { cmd: 'vitest',           flag: '--config',  files: ['vitest.config.js', 'vitest.config.ts', 'vitest.config.mjs'] },
+  { cmd: 'eslint',           flag: '--config',  files: ['eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs'] },
+  { cmd: 'prettier',         flag: '--config',  files: ['prettier.config.js', 'prettier.config.cjs', '.prettierrc.js', 'prettier.config.mjs'] },
+  { cmd: 'jest',             flag: '--config',  files: ['jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs'] },
+  { cmd: 'webpack serve',    flag: '--config',  files: ['webpack.config.js', 'webpack.config.ts', 'webpack.config.mjs'] },
+  { cmd: 'webpack',          flag: '--config',  files: ['webpack.config.js', 'webpack.config.ts', 'webpack.config.mjs'] },
+  { cmd: 'rollup',           flag: '--config',  files: ['rollup.config.js', 'rollup.config.ts', 'rollup.config.mjs'] },
+  { cmd: 'tsup',             flag: '--config',  files: ['tsup.config.js', 'tsup.config.ts', 'tsup.config.mjs'] },
+  { cmd: 'tsc',              flag: '--project', files: ['tsconfig.json', 'tsconfig.build.json', 'tsconfig.prod.json'] },
+  { cmd: 'nodemon',          flag: '--config',  files: ['nodemon.json', '.nodemonrc', 'nodemon.config.js'] },
+  { cmd: 'stylelint',        flag: '--config',  files: ['stylelint.config.js', 'stylelint.config.mjs', 'stylelint.config.cjs', '.stylelintrc.js', '.stylelintrc.json'] },
+  { cmd: 'next build',       flag: '--',        files: [] }, // next doesn't support --config; handled separately
+  { cmd: 'tailwindcss',      flag: '--config',  files: ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.mjs'] },
+  { cmd: 'postcss',          flag: '--config',  files: ['postcss.config.js', 'postcss.config.mjs', 'postcss.config.cjs'] },
+  { cmd: 'babel',            flag: '--config-file', files: ['babel.config.js', 'babel.config.mjs', 'babel.config.cjs', 'babel.config.json'] },
+  { cmd: 'mocha',            flag: '--config',  files: ['.mocharc.js', '.mocharc.cjs', '.mocharc.yml', '.mocharc.json', 'mocha.config.js'] },
+  { cmd: 'nyc',              flag: '--config',  files: ['.nycrc', '.nycrc.json', 'nyc.config.js', 'nyc.config.cjs'] },
+  { cmd: 'cypress run',      flag: '--config-file', files: ['cypress.config.js', 'cypress.config.ts', 'cypress.config.mjs'] },
+  { cmd: 'cypress open',     flag: '--config-file', files: ['cypress.config.js', 'cypress.config.ts', 'cypress.config.mjs'] },
+  { cmd: 'playwright test',  flag: '--config',  files: ['playwright.config.js', 'playwright.config.ts', 'playwright.config.mjs'] },
+]
+
+/**
+ * Tools that use the config file as a POSITIONAL argument (not a --flag).
+ * These files can also be removed from root — the argument in the script is patched.
+ */
+const POSITIONAL_TOOLS = [
+  { cmd: 'pm2 start',   files: ['ecosystem.config.js', 'ecosystem.config.cjs', 'ecosystem.config.mjs'] },
+  { cmd: 'pm2 restart', files: ['ecosystem.config.js', 'ecosystem.config.cjs', 'ecosystem.config.mjs'] },
+  { cmd: 'pm2 reload',  files: ['ecosystem.config.js', 'ecosystem.config.cjs', 'ecosystem.config.mjs'] },
+]
+
+/**
+ * Files that MUST be physically present in the project root.
+ * These cannot be redirected via CLI flags — tools discover them by convention.
+ * Everything in .root/configs/ NOT matching TOOL_CONFIGS or POSITIONAL_TOOLS falls into this category,
+ * but we keep an explicit list for clarity and migrate detection.
+ */
+const ROOT_REQUIRED_FILES = new Set([
+  // Node.js version managers
+  '.nvmrc', '.node-version',
+  // Package managers
+  '.npmrc', '.yarnrc', '.yarnrc.yml', '.pnpmfile.cjs',
+  // Editor
+  '.editorconfig',
+  // Git (root discovery via git, these are auto-found)
+  '.gitignore', '.gitattributes', '.gitmodules',
+  // Docker
+  'Dockerfile', '.dockerignore',
+  // Process / deployment
+  'Procfile',
+  // Browser targets
+  '.browserslistrc', 'browserslist',
+  // Lint ignore files (eslint/prettier look for these automatically)
+  '.eslintignore', '.prettierignore', '.stylelintignore',
+  // Commitlint / lint-staged / release (auto-discovery only)
+  'commitlint.config.js', 'commitlint.config.cjs', 'commitlint.config.mjs',
+  '.commitlintrc', '.commitlintrc.js', '.commitlintrc.json',
+  '.lintstagedrc', '.lintstagedrc.js', '.lintstagedrc.json', '.lintstagedrc.cjs',
+  'lint-staged.config.js', 'lint-staged.config.mjs', 'lint-staged.config.cjs',
+  '.releaserc', '.releaserc.js', '.releaserc.json', '.releaserc.yml',
+  'release.config.js', 'release.config.cjs',
+  // Semantic tooling
+  '.czrc', '.cz.json',
+  // HTTPS / certs
+  '.htaccess',
+  // Web assets
+  'robots.txt', 'sitemap.xml', 'favicon.ico', 'manifest.json', 'site.webmanifest',
+])
+
+/**
+ * Returns true if the file can be redirected away from root via CLI flags.
+ * Files where this returns false MUST be copied to root.
+ */
+function isPatchable(filename) {
+  return (
+    TOOL_CONFIGS.some(t => t.files.includes(filename)) ||
+    POSITIONAL_TOOLS.some(t => t.files.includes(filename))
+  )
+}
+
+/**
+ * Returns true if the file must always be physically present in root.
+ */
+function isRootRequired(filename) {
+  if (ROOT_REQUIRED_FILES.has(filename)) return true
+  // .env* patterns
+  if (/^\.env/.test(filename)) return true
+  // Dockerfile variants: Dockerfile.dev, Dockerfile.prod etc.
+  if (/^Dockerfile/.test(filename)) return true
+  // Not patchable and not in ROOT_REQUIRED_FILES → still copy to be safe
+  if (!isPatchable(filename)) return true
+  return false
+}
+
+/**
+ * Build a map of { cmd → relative config path } based on what actually exists in configsDir.
+ * configsDir is the absolute path to .root/configs/
+ * projectRoot is used to compute relative paths in scripts
+ */
+async function buildConfigMap(configsDir, projectRoot) {
+  let files = []
+  try {
+    files = await readdir(configsDir)
+  } catch {
+    return {}
+  }
+
+  const map = {}
+
+  // Flag-based tools
+  for (const tool of TOOL_CONFIGS) {
+    if (!tool.files.length) continue
+    if (map[tool.cmd]) continue
+    const found = tool.files.find(f => files.includes(f))
+    if (!found) continue
+    const abs = path.join(configsDir, found)
+    const rel = path.relative(projectRoot, abs).replace(/\\/g, '/')
+    map[tool.cmd] = { path: rel.startsWith('.') ? rel : `./${rel}`, flag: tool.flag, positional: false }
+  }
+
+  // Positional tools (pm2 etc.)
+  for (const tool of POSITIONAL_TOOLS) {
+    if (map[tool.cmd]) continue
+    const found = tool.files.find(f => files.includes(f))
+    if (!found) continue
+    const abs = path.join(configsDir, found)
+    const rel = path.relative(projectRoot, abs).replace(/\\/g, '/')
+    map[tool.cmd] = { path: rel.startsWith('.') ? rel : `./${rel}`, flag: null, positional: true, originalFile: found }
+  }
+
+  return map
+}
+
+/**
+ * Inject --config flag into a single script string where missing.
+ * Handles semicolons, &&, || (multi-command scripts).
+ */
+function patchScriptString(script, configMap) {
+  // Sort by command length descending to avoid partial matches
+  const sorted = Object.entries(configMap).sort((a, b) => b[0].length - a[0].length)
+
+  let result = script
+  for (const [cmd, info] of sorted) {
+    if (info.positional) {
+      // Replace filename argument directly: pm2 start ecosystem.config.cjs → pm2 start .root/...
+      for (const file of (POSITIONAL_TOOLS.find(t => t.cmd === cmd)?.files ?? [])) {
+        const escapedFile = file.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        const escapedCmd = cmd.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\s+/g, '\\s+')
+        const regex = new RegExp(`(${escapedCmd})\\s+${escapedFile}`, 'g')
+        result = result.replace(regex, `$1 ${info.path}`)
+      }
+    } else {
+      // Flag-based: insert --config <path> after command if not already present
+      const flag = info.flag
+      const escapedCmd = cmd.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\s+/g, '\\s+')
+      const escapedFlag = flag.replace(/-/g, '\\-')
+      const regex = new RegExp(`((?:^|[;&|\\s]))(${escapedCmd})(?!\\s+${escapedFlag})`, 'g')
+      result = result.replace(regex, (_, pre, match) => `${pre}${match} ${flag} ${info.path}`)
+    }
+  }
+  return result
+}
+
+/**
+ * Patch all scripts in the project's package.json.
+ * Returns true if any scripts were changed.
+ */
+async function patchPackageScripts(projectRoot, configsDir, logger) {
+  const pkgPath = path.join(projectRoot, 'package.json')
+  if (!(await fileExists(pkgPath))) return false
+
+  const pkg = await readJsonFile(pkgPath)
+  if (!pkg.scripts || typeof pkg.scripts !== 'object') return false
+
+  const configMap = await buildConfigMap(configsDir, projectRoot)
+  if (Object.keys(configMap).length === 0) return false
+
+  let changed = false
+  for (const [name, script] of Object.entries(pkg.scripts)) {
+    if (typeof script !== 'string') continue
+    const patched = patchScriptString(script, configMap)
+    if (patched !== script) {
+      pkg.scripts[name] = patched
+      changed = true
+      logger?.debug(`Patched script "${name}": ${patched}`)
+    }
+  }
+
+  if (changed) {
+    await writeJsonFile(pkgPath, pkg)
+  }
+  return changed
+}
+
+/**
+ * Add "prepare": "rootless prepare --yes" to project's package.json.
+ * If prepare already exists and doesn't include rootless, prepends to it.
+ * Returns the final prepare script value.
+ */
+async function addPrepareHook(projectRoot) {
+  const pkgPath = path.join(projectRoot, 'package.json')
+  if (!(await fileExists(pkgPath))) return null
+
+  const pkg = await readJsonFile(pkgPath)
+  if (!pkg.scripts) pkg.scripts = {}
+
+  const existing = pkg.scripts.prepare ?? ''
+  if (existing.includes('rootless prepare')) return existing
+
+  pkg.scripts.prepare = existing
+    ? `rootless prepare --yes && ${existing}`
+    : 'rootless prepare --yes'
+
+  await writeJsonFile(pkgPath, pkg)
+  return pkg.scripts.prepare
+}
+
+export { patchPackageScripts, addPrepareHook, buildConfigMap, patchScriptString, isPatchable, isRootRequired }