rootless-config 1.0.1 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootless-config",
-  "version": "1.0.1",
+  "version": "1.1.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,15 +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 { resolveProjectRoot } from '../../core/pathResolver.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,
@@ -25,11 +25,11 @@ export default {
 
   async handler(args) {
     const logger = createLogger({ verbose: args.verbose ?? false })
-    const projectRoot = await resolveProjectRoot()
+    const projectRoot = args.cwd ? path.resolve(args.cwd) : process.cwd()
     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
@@ -47,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,32 +1,43 @@
 /*-------- 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 { resolveProjectRoot } from '../../core/pathResolver.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/
 
 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.name !== 'package.json') // never migrate 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',
 
   async handler(args) {
     const logger = createLogger({ verbose: args.verbose ?? false })
-    const projectRoot = await resolveProjectRoot()
+    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) {
@@ -36,6 +47,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')
@@ -51,13 +68,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 } from './scriptPatcher.js'
 import { ValidationError } from '../types/errors.js'
 
 async function loadConfig(containerPath) {
@@ -49,9 +50,38 @@ async function preparePipeline(options = {}) {
   const containerPath = await resolveContainerPath()
   const config = ctx.container.manifest ?? {}
   const graph = await getGraph(config)
+  const isCleanMode = (config.mode ?? 'proxy') === 'clean'
 
-  const entries = await buildGenerationEntries(containerPath, graph, ctx)
   const projectRoot = await resolveProjectRoot()
+
+  if (isCleanMode) {
+    // Clean mode: only copy .env files to root, patch package.json scripts for everything else
+    const envDir = path.join(containerPath, 'env')
+    const configsDir = path.join(containerPath, 'configs')
+
+    const envEntries = []
+    if (await fileExists(envDir)) {
+      const envFiles = await readdir(envDir, { withFileTypes: true })
+      for (const f of envFiles) {
+        if (!f.isFile()) continue
+        const absPath = path.join(envDir, f.name)
+        const plugin = ctx.pluginRegistry.resolve(absPath)[0] ?? null
+        envEntries.push({ source: absPath, target: path.join(projectRoot, f.name), mode: 'copy', plugin })
+      }
+    }
+
+    const results = await generateFiles(envEntries, options, ctx.logger)
+
+    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 (default): 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,127 @@
+/*-------- 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'
+
+/**
+ * Known tools: what config files they use and which flag points to a config.
+ * 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',        flag: '--config', files: ['vite.config.js', 'vite.config.ts', 'vite.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'] },
+  { cmd: 'jest',        flag: '--config', files: ['jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs'] },
+  { 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'] },
+  { cmd: 'tsc',         flag: '--project', files: ['tsconfig.json', 'tsconfig.build.json'] },
+  { cmd: 'nodemon',     flag: '--config', files: ['nodemon.json', '.nodemonrc', 'nodemon.config.js'] },
+]
+
+/**
+ * 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 = {}
+  for (const tool of TOOL_CONFIGS) {
+    if (map[tool.cmd]) continue // already mapped (longer cmd took priority)
+    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] = rel.startsWith('.') ? rel : `./${rel}`
+  }
+  return map
+}
+
+/**
+ * Inject --config flag into a single script string where missing.
+ * Handles semicolons, &&, || (multi-command scripts).
+ */
+function patchScriptString(script, configMap) {
+  // Process longer commands first to avoid partial matches (vite build before vite)
+  const sorted = Object.entries(configMap).sort((a, b) => b[0].length - a[0].length)
+
+  let result = script
+  for (const [cmd, configPath] of sorted) {
+    const tool = TOOL_CONFIGS.find(t => t.cmd === cmd)
+    if (!tool) continue
+    const flag = tool.flag
+
+    // Match the command not already followed by its flag
+    // Word boundary on left, ensure flag not already present after the cmd
+    const escapedCmd = cmd.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\s+/g, '\\s+')
+    const regex = new RegExp(`((?:^|[;&|\\s]))(${escapedCmd})(?!\\s+${flag.replace(/-/g, '\\-')})`, 'g')
+    result = result.replace(regex, (_, pre, match) => `${pre}${match} ${flag} ${configPath}`)
+  }
+  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 // already set
+
+  pkg.scripts.prepare = existing
+    ? `rootless prepare --yes && ${existing}`
+    : 'rootless prepare --yes'
+
+  await writeJsonFile(pkgPath, pkg)
+  return pkg.scripts.prepare
+}
+
+export { patchPackageScripts, addPrepareHook, buildConfigMap, patchScriptString }