@deltabox/toolchain 0.0.0-stage → 1.0.7

package/dist/packages/config/src/types.d.ts

@@ -0,0 +1,75 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ZodType } from "zod";
+import { Schema } from "untyped";
+//#region packages/config/src/types.d.ts
+/** The value type an env var resolves to. */
+export type EnvValueType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+/**
+ * The metadata a consumer attaches to a Zod leaf via `.meta()` to describe the
+ * environment variable that backs a configuration value.
+ */
+export interface EnvVarMeta {
+  /** The env var name, e.g. `MYAPP_AUTH_PASSWORD`. */
+  env: string;
+  /** The dotted config path, e.g. `auth.password`. */
+  path?: string;
+  /** Human-readable description (used by `.env.example` + the docs). */
+  description?: string;
+  /** Whether the var has no safe default and must be set. */
+  required?: boolean;
+  /** Whether the value is a secret (never emitted/logged). */
+  secret?: boolean;
+  /** The scope the variable belongs to. */
+  scope?: string;
+  /** Whether the variable is safe to expose to the browser (frontend). */
+  public?: boolean;
+  /**
+   * The resolved-config default, when it differs from the raw env default
+   * (e.g. the positive field behind a negative-named env flag).
+   */
+  defaultValue?: unknown;
+}
+/** A collected env-var definition. */
+export interface EnvVarDef {
+  name: string;
+  path: string;
+  description?: string;
+  default?: unknown;
+  required?: boolean;
+  secret?: boolean;
+  public?: boolean;
+  scope: string;
+  envType?: EnvValueType;
+}
+/** One configuration scope: its Zod schema and an optional resolved schema. */
+export interface ConfigScopeDef {
+  /** The Zod schema (the single source of truth). */
+  zodSchema: ZodType;
+  /** A pre-resolved untyped schema (resolved from the Zod schema if omitted). */
+  jsonSchema?: Schema;
+}
+/** The scopes registered with an engine, keyed by scope name. */
+export type ConfigScopes = Record<string, ConfigScopeDef>;
+/** Options shared by every generator. */
+export interface ConfigEngineOptions {
+  /** The scopes to walk, keyed by scope name (eg. `{ server, frontend, cli }`). */
+  scopes: ConfigScopes;
+  /** The env-var prefix (eg. `MYAPP_`). Kept as a replacement token in code. */
+  envPrefix?: string;
+  /**
+   * The object key that holds the "flat" base config fields, hoisted out of
+   * the nested groups in the generated types/docs (default `base`).
+   */
+  baseGroup?: string;
+  /** The monorepo/project root used for default output paths. */
+  root?: string;
+  /**
+   * Custom env-name -> dotted-path derivation for leaves without an explicit
+   * `path` (eg. to handle dual `PREFIX_`/`VITE_` prefixes).
+   */
+  envPathOf?: (env: string) => string;
+}
+/** Derive the dotted config path from an env var name + prefix. */
+export declare function envPathOf(env: string, prefix?: string): string;
+//#endregion

package/dist/packages/config/src/types.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;function e(e,t=`APP_`){return e.slice(e.startsWith(t)?t.length:0).toLowerCase().replace(/_/g,`.`)}export{e as envPathOf};

package/dist/packages/core/src/graph.d.ts

@@ -0,0 +1,55 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/core/src/graph.d.ts
+/** Directory names never descended into during discovery. */
+export declare const IGNORED_DIRS: Set<string>;
+/** The package managers a lock file can indicate. */
+export type PackageManager = 'yarn' | 'npm' | 'pnpm' | 'bun';
+/** One discovered package (a `package.json` and/or a dbx config directory). */
+export interface ProjectNode {
+  /** The package name (from `package.json`). */
+  name?: string;
+  /** Directory relative to the graph root (posix). */
+  dir: string;
+  /** Whether the directory contains a `dbx.config.*` file. */
+  hasConfig: boolean;
+  /** The dbx config path relative to the root (when present). */
+  config?: string;
+  /** Names of the other discovered projects this one depends on. */
+  dependencies: string[];
+}
+/** The project dependency graph written to `.dbx/toolchain/projects.json`. */
+export interface ProjectGraph {
+  root: string;
+  packageManager?: PackageManager;
+  generatedAt: string;
+  /** Every discovered package. */
+  projects: ProjectNode[];
+  /** The subset with a dbx config (what the tooling syncs). */
+  dbxProjects: ProjectNode[];
+  /** Dbx project dirs (relative) in dependency order (dependencies first). */
+  order: string[];
+}
+export interface BuildProjectGraphOptions {
+  /** Maximum directory depth to descend (default 5). */
+  maxDepth?: number;
+}
+/** Detect the package manager from the lock file present at the root. */
+export declare function detectPackageManager(root: string): PackageManager | undefined;
+/**
+ * Recursively discover projects under `root` and build their dependency graph.
+ * Skips `node_modules`, `.dbx/toolchain` and other common/generated directories.
+ */
+export declare function buildProjectGraph(root: string, options?: BuildProjectGraphOptions): ProjectGraph;
+/**
+ * Topologically order dbx projects so a dependency is always synced before its
+ * dependents. Cycles (or missing edges) fall back to the input order.
+ */
+export declare function orderProjects(dbxProjects: ProjectNode[]): string[];
+/** The path of the generated project graph for a root. */
+export declare function projectGraphPath(root: string): string;
+/** Write the project graph to `<root>/.dbx/toolchain/projects.json`. */
+export declare function writeProjectGraph(root: string, graph?: ProjectGraph): string;
+/** Read the project graph for a root, or `undefined` when it does not exist. */
+export declare function readProjectGraph(root: string): ProjectGraph | undefined;
+//#endregion

package/dist/packages/core/src/graph.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{readJsonAt as t,toJson as n}from"../../shared/src/fs-utils.js";import"../../shared/src/index.js";import{findConfigFile as r}from"./loader.js";import i from"node:fs";const a=/* @__PURE__ */ new Set([`node_modules`,`dist`,`build`,`out`,`coverage`,`tmp`,`temp`,`vendor`,`jspm_packages`,`web_modules`]);function o(e){return e.startsWith(`.`)||a.has(e)}function s(t){try{return i.readdirSync(t,{withFileTypes:!0}).filter(e=>e.isDirectory()&&!o(e.name)).map(n=>e.join(t,n.name))}catch{return[]}}function c(t,n){return e.relative(t,n).replace(/\\/g,`/`)||`.`}function l(t){let n=n=>i.existsSync(e.join(t,n));if(n(`yarn.lock`))return`yarn`;if(n(`pnpm-lock.yaml`))return`pnpm`;if(n(`package-lock.json`))return`npm`;if(n(`bun.lock`)||n(`bun.lockb`))return`bun`}const u=[`dependencies`,`devDependencies`,`peerDependencies`,`optionalDependencies`];function d(e,n={}){let i=n.maxDepth??5,a=/* @__PURE__ */ new Map,o=/* @__PURE__ */ new Map,d=(n,l)=>{let u=t(n,`package.json`),f=r(n);if(u||f){let t={...u?.name?{name:u.name}:{},dir:c(e,n),hasConfig:!!f,...f?{config:c(e,f)}:{},dependencies:[]};a.set(n,t),u?.name&&o.set(u.name,n)}if(!(l>=i))for(let e of s(n))d(e,l+1)};d(e,0);for(let[e,n]of a){let r=t(e,`package.json`);if(!r)continue;let i=/* @__PURE__ */ new Set;for(let t of u){let n=r[t];if(n&&typeof n==`object`)for(let t of Object.keys(n)){let n=o.get(t);n&&n!==e&&i.add(t)}}n.dependencies=[...i].sort()}let p=[...a.values()].sort((e,t)=>e.dir.localeCompare(t.dir)),m=p.filter(e=>e.hasConfig);return{root:e,packageManager:l(e),generatedAt:(/* @__PURE__ */ new Date()).toISOString(),projects:p,dbxProjects:m,order:f(m)}}function f(e){let t=/* @__PURE__ */ new Map;for(let n of e)n.name&&t.set(n.name,n.dir);let n=new Map(e.map(e=>[e.dir,e])),r=/* @__PURE__ */ new Set,i=/* @__PURE__ */ new Set,a=[],o=e=>{if(r.has(e)||i.has(e))return;i.add(e);let s=n.get(e);for(let e of s?.dependencies??[]){let r=t.get(e);r&&n.has(r)&&o(r)}i.delete(e),r.add(e),a.push(e)};for(let t of e)o(t.dir);return a}function p(t){return e.join(t,`.dbx`,`toolchain`,`projects.json`)}function m(t,r){let a=p(t);return i.mkdirSync(e.dirname(a),{recursive:!0}),i.writeFileSync(a,n(r??d(t)),`utf-8`),a}function h(e){try{return JSON.parse(i.readFileSync(p(e),`utf-8`))}catch{return}}export{a as IGNORED_DIRS,d as buildProjectGraph,l as detectPackageManager,f as orderProjects,p as projectGraphPath,h as readProjectGraph,m as writeProjectGraph};

package/dist/packages/core/src/index.d.ts

@@ -0,0 +1,16 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { BuildProjectGraphOptions, IGNORED_DIRS, PackageManager, ProjectGraph, ProjectNode, buildProjectGraph, detectPackageManager, orderProjects, projectGraphPath, readProjectGraph, writeProjectGraph } from "./graph.js";
+import { LoadedConfig, findConfigFile, loadToolingConfig } from "./loader.js";
+import { MANIFEST_DIR, MANIFEST_FILE, Manifest, readManifest, writeManifest } from "./manifest.js";
+import { detectProjectType, resolveProjectType } from "./project-type.js";
+import { SelectProjectsOptions, SelectedProject, selectProjects } from "./select.js";
+import { ResetProjectsOptions, ResetProjectsResult, ResetSelectors, ResetToolingOptions, ResetToolingResult, resetProjects, resetTooling } from "./reset.js";
+import { RunSyncOptions, SyncResult, runSync } from "./sync.js";
+import { VscodeSyncOptions, vscodeSyncTask } from "./vscode.js";
+import { RunWatchOptions, runWatch } from "./watch.js";
+declare namespace index_d_exports {
+  export { BuildProjectGraphOptions, IGNORED_DIRS, LoadedConfig, MANIFEST_DIR, MANIFEST_FILE, Manifest, PackageManager, ProjectGraph, ProjectNode, ResetProjectsOptions, ResetProjectsResult, ResetSelectors, ResetToolingOptions, ResetToolingResult, RunSyncOptions, RunWatchOptions, SelectProjectsOptions, SelectedProject, SyncResult, VscodeSyncOptions, buildProjectGraph, detectPackageManager, detectProjectType, findConfigFile, loadToolingConfig, orderProjects, projectGraphPath, readManifest, readProjectGraph, resetProjects, resetTooling, resolveProjectType, runSync, runWatch, selectProjects, vscodeSyncTask, writeManifest, writeProjectGraph };
+}
+//#endregion
+export { BuildProjectGraphOptions, IGNORED_DIRS, LoadedConfig, MANIFEST_DIR, MANIFEST_FILE, Manifest, PackageManager, ProjectGraph, ProjectNode, ResetProjectsOptions, ResetProjectsResult, ResetSelectors, ResetToolingOptions, ResetToolingResult, RunSyncOptions, RunWatchOptions, SelectProjectsOptions, SelectedProject, SyncResult, VscodeSyncOptions, buildProjectGraph, detectPackageManager, detectProjectType, findConfigFile, index_d_exports, loadToolingConfig, orderProjects, projectGraphPath, readManifest, readProjectGraph, resetProjects, resetTooling, resolveProjectType, runSync, runWatch, selectProjects, vscodeSyncTask, writeManifest, writeProjectGraph };

package/dist/packages/core/src/index.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{__exportAll as e}from"../../../_virtual/_rolldown/runtime.js";import{detectProjectType as t,resolveProjectType as n}from"./project-type.js";import{findConfigFile as r,loadToolingConfig as i}from"./loader.js";import{IGNORED_DIRS as a,buildProjectGraph as o,detectPackageManager as s,orderProjects as c,projectGraphPath as l,readProjectGraph as u,writeProjectGraph as d}from"./graph.js";import{MANIFEST_DIR as f,MANIFEST_FILE as p,readManifest as m,writeManifest as h}from"./manifest.js";import{selectProjects as g}from"./select.js";import{resetProjects as _,resetTooling as v}from"./reset.js";import{runSync as y}from"./sync.js";import{vscodeSyncTask as b}from"./vscode.js";import{runWatch as x}from"./watch.js";var S=/* @__PURE__ */ e({IGNORED_DIRS:()=>a,MANIFEST_DIR:()=>f,MANIFEST_FILE:()=>p,buildProjectGraph:()=>o,detectPackageManager:()=>s,detectProjectType:()=>t,findConfigFile:()=>r,loadToolingConfig:()=>i,orderProjects:()=>c,projectGraphPath:()=>l,readManifest:()=>m,readProjectGraph:()=>u,resetProjects:()=>_,resetTooling:()=>v,resolveProjectType:()=>n,runSync:()=>y,runWatch:()=>x,selectProjects:()=>g,vscodeSyncTask:()=>b,writeManifest:()=>h,writeProjectGraph:()=>d});export{a as IGNORED_DIRS,f as MANIFEST_DIR,p as MANIFEST_FILE,o as buildProjectGraph,s as detectPackageManager,t as detectProjectType,r as findConfigFile,i as loadToolingConfig,c as orderProjects,l as projectGraphPath,m as readManifest,u as readProjectGraph,_ as resetProjects,v as resetTooling,n as resolveProjectType,y as runSync,x as runWatch,g as selectProjects,S as src_exports,b as vscodeSyncTask,h as writeManifest,d as writeProjectGraph};

package/dist/packages/core/src/loader.d.ts

@@ -0,0 +1,27 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Replacements } from "../../shared/src/template.js";
+import { ProjectType } from "../../shared/src/config-schema.js";
+import { ToolingConfig } from "../../shared/src/toolchain.js";
+import "../../shared/src/index.js";
+//#region packages/core/src/loader.d.ts
+/** A loaded tooling config plus its resolved path + replacement tokens. */
+export interface LoadedConfig {
+  config: ToolingConfig;
+  /** The config file that was loaded (undefined when none was found). */
+  path?: string;
+  tokens: Replacements;
+  /** The resolved project kind. */
+  projectType: ProjectType;
+}
+/** Find the first `dbx.config.*` file at `cwd`, if any. */
+export declare function findConfigFile(cwd?: string): string | undefined;
+/**
+ * Load the tooling config for a project. A `dbx.config.*` file exports
+ * `{ toolchain: { ...sections } }`; the `toolchain` value is unwrapped here so
+ * the rest of the toolchain works with flat sections. When no config file (or no
+ * `toolchain` key) exists an empty config is returned (so every task falls back
+ * to its defaults).
+ */
+export declare function loadToolingConfig(cwd?: string): Promise<LoadedConfig>;
+//#endregion

package/dist/packages/core/src/loader.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import{pathToFileURL as t}from"node:url";import.meta.url;import{CONFIG_FILE_NAMES as n,resolveTokens as r}from"../../shared/src/toolchain.js";import"../../shared/src/index.js";import{resolveProjectType as i}from"./project-type.js";import a from"node:fs";function o(t=process.cwd()){for(let r of n){let n=e.resolve(t,r);if(a.existsSync(n))return n}}async function s(e){if(e.endsWith(`.json`))return JSON.parse(a.readFileSync(e,`utf-8`));let n=t(e).href;try{let e=await import(n);return e.default??e}catch(e){try{let{tsImport:e}=await import(`C:\\Users\\user\\coding\\projects\\deltabox\\@deltabox\\toolchain\\node_modules\\tsx\\dist\\esm\\api\\index.mjs`),t=await e(n,import.meta.url);return t.default??t}catch{throw e}}}async function c(e=process.cwd()){let t=o(e),n={};if(t){let e=await s(t),r=e&&typeof e==`object`?e.toolchain:void 0;r&&typeof r==`object`&&(n=r)}let a=r(n);return await n.hooks?.afterLoad?.({cwd:e,config:n,tokens:a,...t?{path:t}:{}}),{config:n,...t?{path:t}:{},tokens:a,projectType:i(e,n)}}export{o as findConfigFile,c as loadToolingConfig};

package/dist/packages/core/src/manifest.d.ts

@@ -0,0 +1,17 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/core/src/manifest.d.ts
+/** The manifest directory + file recording every file the tooling manages. */
+export declare const MANIFEST_DIR = ".dbx/toolchain";
+export declare const MANIFEST_FILE = "manifest.json";
+export interface Manifest {
+  /** Repo-relative paths of every generated/managed file. */
+  files: string[];
+  /** ISO timestamp of the last successful sync (absent when never synced). */
+  syncedAt?: string;
+}
+/** Read the manifest (`{ files: [] }` when missing/invalid). */
+export declare function readManifest(cwd: string): Manifest;
+/** Write the manifest, creating the directory as needed. */
+export declare function writeManifest(cwd: string, files: string[], syncedAt?: string): void;
+//#endregion

package/dist/packages/core/src/manifest.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{toJson as t}from"../../shared/src/fs-utils.js";import"../../shared/src/index.js";import n from"node:fs";const r=`.dbx/toolchain`,i=`manifest.json`;function a(t){let a=e.resolve(t,r,i);try{let e=JSON.parse(n.readFileSync(a,`utf-8`));return{files:Array.isArray(e.files)?e.files:[],...typeof e.syncedAt==`string`?{syncedAt:e.syncedAt}:{}}}catch{return{files:[]}}}function o(a,o,s){let c=e.resolve(a,r,i);n.mkdirSync(e.dirname(c),{recursive:!0}),n.writeFileSync(c,t({files:[...new Set(o)].sort(),syncedAt:s??(/* @__PURE__ */ new Date()).toISOString()}),`utf-8`)}export{r as MANIFEST_DIR,i as MANIFEST_FILE,a as readManifest,o as writeManifest};

package/dist/packages/core/src/project-type.d.ts

@@ -0,0 +1,14 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ProjectType } from "../../shared/src/config-schema.js";
+import { ToolingConfig } from "../../shared/src/toolchain.js";
+import "../../shared/src/index.js";
+//#region packages/core/src/project-type.d.ts
+/**
+ * Resolve the project kind: an explicit `project.type` in the config wins,
+ * otherwise it is detected from the filesystem.
+ */
+export declare function resolveProjectType(cwd: string, config?: ToolingConfig): ProjectType;
+/** Detect the project kind from `cwd` (workspaces / monorepo file heuristics). */
+export declare function detectProjectType(cwd: string): ProjectType;
+//#endregion

package/dist/packages/core/src/project-type.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{readJsonAt as t}from"../../shared/src/fs-utils.js";import"../../shared/src/index.js";import n from"node:fs";function r(e,t={}){return t.project?.type?t.project.type:i(e)}function i(r){let i=t(r,`package.json`)?.workspaces;return(Array.isArray(i)?i.length>0:i&&Array.isArray(i.packages)&&i.packages.length>0)||n.existsSync(e.join(r,`tsconfig.monorepo.json`))?`monorepo-root`:n.existsSync(e.join(r,`tsconfig.default.json`))?`monorepo-workspace`:`project`}export{i as detectProjectType,r as resolveProjectType};

package/dist/packages/core/src/reset.d.ts

@@ -0,0 +1,51 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { SelectProjectsOptions } from "./select.js";
+//#region packages/core/src/reset.d.ts
+/** What parts of the tooling to remove for a project. */
+export interface ResetSelectors {
+  /** Remove the generated/managed files listed in the manifest. */
+  generated?: boolean;
+  /** Remove the `.dbx/toolchain` directory (manifest + graph). */
+  manifest?: boolean;
+  /** Remove the `dbx.config.*` file(s). */
+  config?: boolean;
+}
+export interface ResetToolingOptions extends ResetSelectors {
+  /** The project directory to reset. */
+  cwd: string;
+  /** Report what would be removed without deleting anything. */
+  dryRun?: boolean;
+}
+export interface ResetToolingResult {
+  /** Repo-relative paths removed (or that would be removed). */
+  removed: string[];
+  /** Whether this was a dry run. */
+  dryRun: boolean;
+}
+/**
+ * Remove the tooling artifacts from a single project: the generated files
+ * recorded in `.dbx/toolchain/manifest.json`, the `.dbx/toolchain` directory and/or
+ * the `dbx.config.*` file. With no selectors the generated files + the
+ * manifest directory are removed (the config is kept).
+ */
+export declare function resetTooling(options: ResetToolingOptions): ResetToolingResult;
+export interface ResetProjectsOptions extends ResetSelectors, Omit<SelectProjectsOptions, 'kind'> {
+  /** Apply to every discovered project under `root` (not just `root`). */
+  recursive?: boolean;
+  dryRun?: boolean;
+}
+export interface ResetProjectsResult {
+  results: {
+    dir: string;
+    rel: string;
+    removed: string[];
+  }[];
+  dryRun: boolean;
+}
+/**
+ * Reset one or many projects. When `recursive` is set every discovered project
+ * (optionally filtered by `include`/`exclude`) is reset; otherwise only `root`.
+ */
+export declare function resetProjects(options: ResetProjectsOptions): ResetProjectsResult;
+//#endregion

package/dist/packages/core/src/reset.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{findConfigFile as t}from"./loader.js";import{MANIFEST_DIR as n,readManifest as r}from"./manifest.js";import{selectProjects as i}from"./select.js";import a from"node:fs";function o(e){return e.replace(/\\/g,`/`)}function s(e){let t=e.generated!==void 0||e.manifest!==void 0||e.config!==void 0;return{generated:e.generated??!t,manifest:e.manifest??!t,config:e.config??!1}}function c(i){let{cwd:c}=i,l=i.dryRun??!1,u=s(i),d=[],f=(e,t)=>{a.existsSync(e)&&(l||a.rmSync(e,{force:!0}),d.push(t))};if(u.generated)for(let t of r(c).files)f(e.resolve(c,t),t);if(u.config){let n=t(c);n&&f(n,o(e.relative(c,n)))}if(u.manifest){let t=e.resolve(c,n);a.existsSync(t)&&(l||a.rmSync(t,{recursive:!0,force:!0}),d.push(`${n}/`))}return{removed:d,dryRun:l}}function l(e){let n=e.dryRun??!1;return{results:(e.recursive?i({root:e.root,...e.include?{include:e.include}:{},...e.exclude?{exclude:e.exclude}:{},...e.maxDepth===void 0?{}:{maxDepth:e.maxDepth}}):[{dir:e.root,rel:`.`,hasConfig:!!t(e.root)}]).map(t=>({dir:t.dir,rel:t.rel,removed:c({cwd:t.dir,...e.generated===void 0?{}:{generated:e.generated},...e.manifest===void 0?{}:{manifest:e.manifest},...e.config===void 0?{}:{config:e.config},dryRun:n}).removed})),dryRun:n}}export{l as resetProjects,c as resetTooling};

package/dist/packages/core/src/select.d.ts

@@ -0,0 +1,32 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/core/src/select.d.ts
+/** A project selected by {@link selectProjects}. */
+export interface SelectedProject {
+  /** Absolute project directory. */
+  dir: string;
+  /** Directory relative to the root (posix). */
+  rel: string;
+  /** Package name when available. */
+  name?: string;
+  /** Whether the directory has a `dbx.config.*`. */
+  hasConfig: boolean;
+}
+export interface SelectProjectsOptions {
+  /** Root to scan. */
+  root: string;
+  /** Keep only projects matching one of these patterns (glob or substring). */
+  include?: string[];
+  /** Drop projects matching any of these patterns (glob or substring). */
+  exclude?: string[];
+  /**
+   * What to keep: `all` (default), `configured` (has a dbx config) or
+   * `unconfigured` (missing a dbx config).
+   */
+  kind?: 'all' | 'configured' | 'unconfigured';
+  /** Maximum directory depth to scan (default 5). */
+  maxDepth?: number;
+}
+/** Discover projects under a root, applying include/exclude + kind filters. */
+export declare function selectProjects(options: SelectProjectsOptions): SelectedProject[];
+//#endregion

package/dist/packages/core/src/select.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{buildProjectGraph as t}from"./graph.js";const n=/[*?[\]{}]/,r=`<<dbx-globstar>>`;function i(e){let t=e.replace(/[.+^${}()|\\]/g,`\\$&`).replace(/\*\*/g,r).replace(/\*/g,`[^/]*`).replaceAll(r,`.*`).replace(/\?/g,`.`);return RegExp(`^${t}$`,`i`)}function a(t,r){let a=[t.rel,t.name??``,e.basename(t.rel)];if(n.test(r)){let e=i(r);return a.some(t=>e.test(t))}let o=r.toLowerCase();return a.some(e=>e.toLowerCase().includes(o))}function o(n){let r=t(n.root,n.maxDepth===void 0?{}:{maxDepth:n.maxDepth}).projects.map(t=>({dir:e.resolve(n.root,t.dir),rel:t.dir,...t.name?{name:t.name}:{},hasConfig:t.hasConfig})),i=n.kind??`all`,o=n.include?.filter(Boolean)??[],s=n.exclude?.filter(Boolean)??[];return r.filter(e=>!(i===`configured`&&!e.hasConfig||i===`unconfigured`&&e.hasConfig||o.length>0&&!o.some(t=>a(e,t))||s.some(t=>a(e,t))))}export{o as selectProjects};

package/dist/packages/core/src/sync.d.ts

@@ -0,0 +1,42 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Replacements } from "../../shared/src/template.js";
+import { ProjectType } from "../../shared/src/config-schema.js";
+import { SyncTask, ToolingConfig } from "../../shared/src/toolchain.js";
+import "../../shared/src/index.js";
+//#region packages/core/src/sync.d.ts
+export interface RunSyncOptions {
+  /** The task list to run. */
+  tasks: SyncTask[];
+  /** The project root. */
+  cwd: string;
+  /** The loaded config. */
+  config: ToolingConfig;
+  /** The resolved replacement tokens. */
+  tokens: Replacements;
+  /** The project kind (resolved from the config/cwd when omitted). */
+  projectType?: ProjectType;
+  /** Dry-run: report drift and exit non-zero without writing. */
+  check?: boolean;
+  /** Suppress logging. */
+  quiet?: boolean;
+  /** Custom logger (default `console.log`). */
+  log?: (message: string) => void;
+}
+export interface SyncResult {
+  /** Paths written (empty in check mode). */
+  written: string[];
+  /** Paths whose generated content differs from disk. */
+  changed: string[];
+  /** Previously-managed paths removed because they are no longer generated. */
+  removed: string[];
+  /** Whether disk already matched the generated output. */
+  upToDate: boolean;
+}
+/**
+ * Run every enabled sync task, writing the managed files and pruning files that
+ * are no longer generated. With `check: true` nothing is written: drift is
+ * reported instead (for CI).
+ */
+export declare function runSync(options: RunSyncOptions): Promise<SyncResult>;
+//#endregion

package/dist/packages/core/src/sync.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{resolveProjectType as t}from"./project-type.js";import{readManifest as n,writeManifest as r}from"./manifest.js";import i from"node:fs";function a(e){return e.replace(/\\/g,`/`)}async function o(o){let{tasks:s,cwd:c,config:l,tokens:u}=o,d=o.quiet?()=>{}:o.log??(e=>console.log(e)),f=o.projectType??t(c,l),p={cwd:c,projectType:f,config:l,tokens:u,log:d},m=l.hooks??{};await m.beforeSync?.(p);let h=s.filter(e=>(!e.projectTypes||e.projectTypes.includes(f))&&(!e.enabled||e.enabled(l)));d(`dbx: running ${h.length} task(s)${o.check?` (check)`:``} [${f}]`);let g=[];for(let e of h){d(`  - ${e.name}`),await m.beforeTask?.({task:e,ctx:p});let t=await e.run(p),n=Array.isArray(t)?t:void 0;n&&g.push(...n),await m.afterTask?.({task:e,ctx:p,...n?{files:n}:{}})}let _=new Map(g.map(e=>[a(e.path),e.content])),v=n(c),y=/* @__PURE__ */ new Set;for(let e of h)for(let t of e.keep??[])y.add(t);let b=e=>{for(let t of y)if(e===t||e.endsWith(`/${t}`)||e.endsWith(t))return!0;return!1},x=[];for(let[t,n]of _){let r=e.resolve(c,t);(i.existsSync(r)?i.readFileSync(r,`utf-8`):void 0)!==n&&x.push(t)}let S=v.files.filter(t=>!_.has(t)&&!b(t)&&i.existsSync(e.resolve(c,t))),C=x.length===0&&S.length===0;if(o.check){if(C)d(`dbx: generated files are in sync.`);else{d(`dbx: generated files are out of date:`);for(let e of x)d(`  M ${e}`);for(let e of S)d(`  D ${e}`);d("Run `dbx sync` to regenerate them.")}let e={written:[],changed:x,removed:S,upToDate:C};return await m.afterSync?.({cwd:c,config:l,result:e}),e}let w=[];for(let[t,n]of _){let r=e.resolve(c,t);i.mkdirSync(e.dirname(r),{recursive:!0}),i.writeFileSync(r,n,`utf-8`),w.push(t)}for(let t of S)i.rmSync(e.resolve(c,t),{force:!0});r(c,[..._.keys()]),d(`dbx: wrote ${w.length}, removed ${S.length} file(s)${x.length?`, updated ${x.length}`:``}.`);let T={written:w,changed:x,removed:S,upToDate:C};return await m.afterSync?.({cwd:c,config:l,result:T}),T}export{o as runSync};

package/dist/packages/core/src/vscode.d.ts

@@ -0,0 +1,27 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ProjectType } from "../../shared/src/config-schema.js";
+import { SyncTask, ToolingConfig } from "../../shared/src/toolchain.js";
+import "../../shared/src/index.js";
+//#region packages/core/src/vscode.d.ts
+export interface VscodeSyncOptions {
+  /**
+   * Settings patches, deep-merged in order (then merged into the consumer's).
+   * A function lets the patches depend on the config (eg. only inject Biome
+   * settings when the `biome` section is enabled).
+   */
+  settings?: Record<string, unknown>[] | ((config: ToolingConfig) => Record<string, unknown>[]);
+  /** Recommended extensions (unioned with the consumer's existing list). */
+  extensions?: string[];
+  /** Whether the task runs (default: always). */
+  enabled?: (config: ToolingConfig) => boolean;
+  /** The project kinds the task applies to (default root + single project). */
+  projectTypes?: ProjectType[];
+}
+/**
+ * The VS Code sync task: merges the given settings/extensions into the
+ * consumer's `.vscode/settings.json` / `.vscode/extensions.json`, preserving
+ * whatever they already have.
+ */
+export declare function vscodeSyncTask(options?: VscodeSyncOptions): SyncTask;
+//#endregion

package/dist/packages/core/src/vscode.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{deepMerge as e}from"../../shared/src/object-utils.js";import{mergeJsonAt as t}from"../../shared/src/fs-utils.js";import"../../shared/src/index.js";function n(n={}){return{name:`vscode`,projectTypes:n.projectTypes??[`monorepo-root`,`project`],...n.enabled?{enabled:n.enabled}:{},run:r=>{let i=[],a=(typeof n.settings==`function`?n.settings(r.config):n.settings??[]).reduce((t,n)=>e(t,n),{});return Object.keys(a).length>0&&i.push({path:`.vscode/settings.json`,content:t(r.cwd,`.vscode/settings.json`,a)}),n.extensions?.length&&i.push({path:`.vscode/extensions.json`,content:t(r.cwd,`.vscode/extensions.json`,{recommendations:n.extensions})}),i}}}export{n as vscodeSyncTask};

package/dist/packages/core/src/watch.d.ts

@@ -0,0 +1,17 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { RunSyncOptions } from "./sync.js";
+//#region packages/core/src/watch.d.ts
+export interface RunWatchOptions extends Omit<RunSyncOptions, 'check'> {
+  /** The config file to watch (re-runs every task on change). */
+  configPath?: string;
+  /** Debounce window in ms (default 150). */
+  debounce?: number;
+}
+/**
+ * Run one sync, then watch the config file + every task's `watch` globs and
+ * re-run on change. Writing generated files must not re-trigger a run, so a
+ * short quiet window follows each sync.
+ */
+export declare function runWatch(options: RunWatchOptions): Promise<void>;
+//#endregion

package/dist/packages/core/src/watch.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{runSync as t}from"./sync.js";import n from"node:fs";import{Glob as r}from"glob";async function i(i){let{cwd:a,tasks:o}=i,s=i.debounce??150,c=i.quiet?()=>{}:i.log??(e=>console.log(e)),l=0,u,d=!1,f=!1,p=async()=>{if(d)f=!0;else{d=!0;try{await t(i)}finally{d=!1,l=Date.now()+Math.max(s*3,300),f&&(f=!1,m())}}},m=()=>{clearTimeout(u),u=setTimeout(p,s)};await p();let h=/* @__PURE__ */ new Set([a]),g=/* @__PURE__ */ new Set;for(let e of o)for(let t of e.watch??[])g.add(t);for(let t of g)try{let n=new r(t,{cwd:a,dot:!0,ignore:[`**/node_modules/**`]}).walkSync();for(let t of n)h.add(e.dirname(e.resolve(a,t)))}catch{}let _=[],v=e=>{Date.now()<l||(i.config?.hooks?.onChange?.(e?{path:e}:{}),m())};if(i.configPath)try{_.push(n.watch(i.configPath,()=>{c(`config changed; re-syncing`),v(i.configPath)}))}catch{}for(let e of h)try{_.push(n.watch(e,{recursive:!0},(e,t)=>v(t??void 0)))}catch{try{_.push(n.watch(e,(e,t)=>v(t??void 0)))}catch{}}c(`dbx: watching for changes (Ctrl+C to stop)`),await new Promise(e=>{let t=()=>{for(let e of _)e.close();process.off(`SIGINT`,t),process.off(`SIGTERM`,t),e()};process.on(`SIGINT`,t),process.on(`SIGTERM`,t)})}export{i as runWatch};

package/dist/packages/migrate/src/biome.d.ts

@@ -0,0 +1,18 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ToolingMigration } from "./types.js";
+//#region packages/migrate/src/biome.d.ts
+/** The Biome config file names, in priority order. */
+export declare const BIOME_CONFIG_FILES: readonly ['biome.json', 'biome.jsonc'];
+/** The Biome config path in `cwd`, if present. */
+export declare function findBiomeConfig(cwd: string): string | undefined;
+/**
+ * Strip JSONC comments + trailing commas. String-aware, so glob patterns such as
+ * `**\/*\/dist` (which contain `/*`) are never mistaken for comments.
+ */
+export declare function stripJsonc(input: string): string;
+/** Read and parse a JSON/JSONC file (BOM-tolerant). */
+export declare function readJsonc(file: string): Record<string, any>;
+/** Build the Biome -> ox migration. */
+export declare const biomeToOx: ToolingMigration;
+//#endregion

package/dist/packages/migrate/src/biome.js

@@ -0,0 +1,2 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{mapBiomeToOxfmt as t}from"./oxfmt-map.js";import{mapBiomeToOxlint as n}from"./oxlint-map.js";import{renderViteTarget as r}from"./vite-target.js";import i from"node:fs";const a=[`biome.json`,`biome.jsonc`];function o(t){for(let n of a){let r=e.join(t,n);if(i.existsSync(r))return r}}function s(e){let t=``,n=!1,r=``;for(let i=0;i<e.length;i++){let a=e[i];if(n)t+=a,a===`\\`?(t+=e[i+1]??``,i++):a===r&&(n=!1);else if(a===`"`||a===`'`)n=!0,r=a,t+=a;else if(a===`/`&&e[i+1]===`/`)for(;i<e.length&&e[i]!==`
+`;)i++;else if(a===`/`&&e[i+1]===`*`){for(i+=2;i<e.length&&(e[i]!==`*`||e[i+1]!==`/`);)i++;i++}else t+=a}return t.replace(/,(\s*[}\]])/g,`$1`)}function c(e){let t=i.readFileSync(e,`utf-8`).replace(/^\uFEFF/,``);return JSON.parse(s(t))}const l={id:`biome-to-ox`,from:`biome`,to:`ox`,description:`Migrate Biome (formatter + organizeImports + linter) to Oxfmt/Oxlint.`,detect:e=>!!o(e),run:async a=>{let s=o(a.cwd);if(!s)throw Error(`biome-to-ox: no biome.json/biome.jsonc found.`);let u=c(s),d=t(u),f=n(u,d.oxfmt.ignorePatterns??[]),p=[...d.unmapped,...f.unmapped],m=[`Source: ${e.basename(s)}.`,`Formatter + organizeImports + linter rules mapped.`];if((a.target??`files`)===`vite`){let e=r(a.cwd,{fmt:d.oxfmt,lint:f.oxlint});return a.write&&i.writeFileSync(e.path,e.content,`utf-8`),{id:l.id,from:`biome`,to:`ox`,written:[e.path],files:[e],oxfmt:d.oxfmt,oxlint:f.oxlint,unmapped:p,notes:[...m,"Folded into vite.config.ts (`fmt` + `lint`)."]}}let h=[[`.oxfmtrc.json`,d.oxfmt],[`.oxlintrc.json`,f.oxlint]].map(([t,n])=>({path:e.join(a.cwd,t),content:`${JSON.stringify(n,null,4)}\n`}));if(a.write)for(let e of h)i.writeFileSync(e.path,e.content,`utf-8`);return{id:l.id,from:`biome`,to:`ox`,written:h.map(e=>e.path),files:h,oxfmt:d.oxfmt,oxlint:f.oxlint,unmapped:p,notes:[...m,"Next: run `oxfmt` to reformat, then drop Biome.","Tip: `--target vite` folds this into vite.config.ts instead."]}}};export{a as BIOME_CONFIG_FILES,l as biomeToOx,o as findBiomeConfig,c as readJsonc,s as stripJsonc};

package/dist/packages/migrate/src/check.d.ts

@@ -0,0 +1,14 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { MigrationFile } from "./types.js";
+//#region packages/migrate/src/check.d.ts
+export type FileStatus = 'missing' | 'changed' | 'same';
+export interface FileDiff {
+  path: string;
+  status: FileStatus;
+}
+/** Compare produced files against disk (`missing` / `changed` / `same`). */
+export declare function diffFiles(files: MigrationFile[]): FileDiff[];
+/** Whether any produced file is missing or out of date. */
+export declare function hasPending(diffs: FileDiff[]): boolean;
+//#endregion

package/dist/packages/migrate/src/check.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import e from"node:fs";function t(t){return t.map(t=>{if(!e.existsSync(t.path))return{path:t.path,status:`missing`};let n=e.readFileSync(t.path,`utf-8`).replace(/^\uFEFF/,``),r=t.content.replace(/^\uFEFF/,``);return{path:t.path,status:n===r?`same`:`changed`}})}function n(e){return e.some(e=>e.status!==`same`)}export{t as diffFiles,n as hasPending};

package/dist/packages/migrate/src/cli/index.d.ts

@@ -0,0 +1,12 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ToolingCommand } from "../../../shared/src/types.js";
+import "../../../shared/src/index.js";
+//#region packages/migrate/src/cli/index.d.ts
+/**
+ * `dbx migrate` — convert a project's tooling config from another
+ * tool (Biome / ESLint / Prettier / Dprint) to Ox (Oxfmt / Oxlint). Dry-run by
+ * default; pass `--write` to apply, or `--check` for a CI gate.
+ */
+export declare function migrateCommands(): ToolingCommand[];
+//#endregion

package/dist/packages/migrate/src/cli/index.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{diffFiles as t,hasPending as n}from"../check.js";import{detectMigrations as r,listMigrations as i,migrations as a}from"../registry.js";function o(){return[{name:`migrate`,description:`Migrate Biome / ESLint / Prettier / Dprint config to Ox (oxlint + oxfmt).`,options:[{flags:`--from <tool>`,description:`Source tool: biome | eslint | prettier | dprint | all.`},{flags:`--to <tool>`,description:`Target tool (default: ox).`,default:`ox`},{flags:`--cwd <dir>`,description:`Project root (default: cwd).`},{flags:`--write`,description:`Write the files (default: dry-run).`},{flags:`--dry-run`,description:`Do not write anything (default).`},{flags:`--check`,description:`CI: exit non-zero when the ox config is stale.`},{flags:`--target <target>`,description:`files (default) | vite.`},{flags:`--online`,description:`Allow network (e.g. @oxlint/migrate).`},{flags:`--json`,description:`Print the result as JSON.`}],run:async(i,o)=>{let s=i.cwd??o.cwd,c=!!i.check,l=!!i.write&&!i.dryRun&&!c,u=!!i.online,d=i.from,f=i.target??`files`,p=!d||d===`all`?r(s):a().filter(e=>e.from===d);if(p.length===0){console.log(d&&d!==`all`?`dbx: no "${d}" migration is registered.`:`dbx: nothing to migrate (no Biome/ESLint/Prettier/Dprint config detected).`);return}let m=[];for(let e of p)m.push(await e.run({cwd:s,write:l,online:u,target:f}));if(c){let r=m.flatMap(e=>t(e.files??[])),a=r.filter(e=>e.status!==`same`);if(i.json)console.log(JSON.stringify(m,null,4));else if(a.length){for(let t of a)console.log(`dbx: ${t.status}  ${e.relative(s,t.path)||t.path}`);console.log(`dbx: ${a.length} file(s) out of date — run \`migrate --write\` to apply.`)}else console.log(`dbx: up to date.`);n(r)&&(process.exitCode=1)}else if(i.json)console.log(JSON.stringify(m,null,4));else{for(let e of m){console.log(`dbx: ${e.from} -> ${e.to} ${l?`wrote`:`would write`}`);for(let t of e.written)console.log(`  ${l?`+`:`?`} ${t}`);for(let t of e.notes??[])console.log(`  ${t}`);if(e.unmapped?.length){console.log(`  unmapped (${e.unmapped.length}):`);for(let t of e.unmapped.slice(0,25))console.log(`    - ${t.source}: ${t.reason}`)}}l||console.log(`dbx: dry-run — re-run with --write to apply.`)}}},{name:`migrate:list`,description:`List the registered migrations and whether each is detected.`,options:[{flags:`--cwd <dir>`,description:`Project root (default: cwd).`},{flags:`--json`,description:`Print as JSON.`}],run:(e,t)=>{let n=e.cwd??t.cwd,r=i(n);if(e.json)console.log(JSON.stringify(r,null,4));else for(let e of r)console.log(`  ${e.id.padEnd(16)} ${e.from} -> ${e.to}  [${e.detected?`detected`:`not found`}]`),console.log(`    ${e.description}`)}}]}export{o as migrateCommands};

package/dist/packages/migrate/src/dprint.d.ts

@@ -0,0 +1,18 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ToolingMigration } from "./types.js";
+//#region packages/migrate/src/dprint.d.ts
+type Json = Record<string, any>;
+/** Locate a dprint config. */
+export declare function findDprintConfig(cwd: string): {
+  file: string;
+  config: Json;
+} | undefined;
+/** Map a dprint config to Oxfmt options. */
+export declare function mapDprintToOxfmt(dprint: Json): {
+  oxfmt: Json;
+  unmapped: string[];
+};
+export declare const dprintToOx: ToolingMigration;
+//#endregion
+export {};

package/dist/packages/migrate/src/dprint.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{renderViteTarget as t}from"./vite-target.js";import n from"node:fs";const r=[`dprint.json`,`dprint.jsonc`,`.dprint.json`];function i(t){for(let i of r){let r=e.join(t,i);if(!n.existsSync(r))continue;let a=n.readFileSync(r,`utf-8`).replace(/^\uFEFF/,``).replace(/\/\*[\s\S]*?\*\//g,``).replace(/(^|[^:])\/\/.*$/gm,`$1`).replace(/,(\s*[}\]])/g,`$1`);try{return{file:r,config:JSON.parse(a)}}catch{}}}function a(e){let t={},n=e.typescript??{};typeof e.lineWidth==`number`&&(t.printWidth=e.lineWidth),typeof e.indentWidth==`number`&&(t.tabWidth=e.indentWidth),typeof e.useTabs==`boolean`&&(t.useTabs=e.useTabs),(e.newLineKind===`lf`||e.newLineKind===`crlf`)&&(t.endOfLine=e.newLineKind),n.quoteStyle&&(t.singleQuote=String(n.quoteStyle).includes(`Single`)||n.quoteStyle===`alwaysSingle`),n.semiColons&&(t.semi=n.semiColons!==`asi`),n.trailingCommas&&(t.trailingComma=n.trailingCommas===`always`?`all`:n.trailingCommas===`never`?`none`:`es5`);let r=[],i=[`lineWidth`,`indentWidth`,`useTabs`,`newLineKind`,`typescript`,`plugins`];for(let t of Object.keys(e))i.includes(t)||r.push(`dprint section: ${t}`);return Array.isArray(e.plugins)&&e.plugins.length&&r.push(`plugins (Oxfmt has built-in equivalents for common cases)`),{oxfmt:t,unmapped:r}}const o={id:`dprint-to-ox`,from:`dprint`,to:`oxfmt`,description:`Migrate a dprint.json (formatter) to Oxfmt.`,detect:e=>!!i(e),run:async r=>{let o=i(r.cwd);if(!o)throw Error(`dprint-to-ox: no dprint.json found.`);let s=a(o.config),c=s.unmapped.map(e=>({source:e,reason:`no Oxfmt equivalent`})),l=[`Source: ${e.basename(o.file)}.`];if((r.target??`files`)===`vite`){let e=t(r.cwd,{fmt:s.oxfmt});return r.write&&n.writeFileSync(e.path,e.content,`utf-8`),{id:`dprint-to-ox`,from:`dprint`,to:`oxfmt`,written:[e.path],files:[e],oxfmt:s.oxfmt,unmapped:c,notes:[...l,"Folded into vite.config.ts (`fmt`)."]}}let u={path:e.join(r.cwd,`.oxfmtrc.json`),content:`${JSON.stringify(s.oxfmt,null,4)}\n`};return r.write&&n.writeFileSync(u.path,u.content,`utf-8`),{id:`dprint-to-ox`,from:`dprint`,to:`oxfmt`,written:[u.path],files:[u],oxfmt:s.oxfmt,unmapped:c,notes:l}}};export{o as dprintToOx,i as findDprintConfig,a as mapDprintToOxfmt};

package/dist/packages/migrate/src/eslint.d.ts

@@ -0,0 +1,24 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ToolingMigration } from "./types.js";
+//#region packages/migrate/src/eslint.d.ts
+type Json = Record<string, any>;
+/** The ESLint config in `cwd`, preferring JSON (parseable) then JS. */
+export declare function findEslintConfig(cwd: string): {
+  file: string;
+  json: boolean;
+} | undefined;
+/** Map an ESLint rule name to an Oxlint rule name. */
+export declare function mapRuleName(name: string): {
+  name: string;
+  mapped: boolean;
+};
+/**
+ * Evaluate a JS/flat ESLint config with the official `@oxlint/migrate` and read
+ * the `.oxlintrc.json` it writes. Returns `undefined` on failure. Note: the
+ * migrator writes to disk, so callers only run it when writing.
+ */
+export declare function runOxlintMigrate(cwd: string): Promise<Json | undefined>;
+export declare const eslintToOx: ToolingMigration;
+//#endregion
+export {};

package/dist/packages/migrate/src/eslint.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{spawnCross as t}from"../../shared/src/run.js";import"../../shared/src/index.js";import{renderViteTarget as n}from"./vite-target.js";import r from"node:fs";const i=[`.eslintrc.json`,`.eslintrc`],a=[`eslint.config.js`,`eslint.config.mjs`,`eslint.config.cjs`,`eslint.config.ts`,`.eslintrc.js`,`.eslintrc.cjs`];function o(t){for(let n of i){let i=e.join(t,n);if(r.existsSync(i))return{file:i,json:!0}}for(let n of a){let i=e.join(t,n);if(r.existsSync(i))return{file:i,json:!1}}}function s(e){let t=Array.isArray(e)?e[0]:e;return t===2||t===`error`?`error`:t===1||t===`warn`?`warn`:`off`}function c(e){return e.startsWith(`@typescript-eslint/`)?{name:`typescript/${e.slice(19)}`,mapped:!0}:{name:e,mapped:!0}}function l(e,t,n){for(let[r,i]of Object.entries(e??{})){let e=c(r);t[e.name]=s(i),e.mapped||n.push({source:r,reason:`unknown plugin prefix`})}}function u(e,n,r){return new Promise(i=>{let a=t(e,n,{cwd:r,stdio:`inherit`});a.on(`error`,()=>i(1)),a.on(`exit`,e=>i(e??0))})}async function d(t){let n=e.join(t,`.oxlintrc.json`);if(await u(`npx`,[`--yes`,`@oxlint/migrate`],t)===0&&r.existsSync(n))try{return JSON.parse(r.readFileSync(n,`utf-8`).replace(/^\uFEFF/,``))}catch{return}}const f={id:`eslint-to-ox`,from:`eslint`,to:`oxlint`,description:`Migrate ESLint to Oxlint (JSON configs; flat configs via @oxlint/migrate --online).`,detect:e=>!!o(e),run:async t=>{let i=o(t.cwd);if(!i)throw Error(`eslint-to-ox: no ESLint config found.`);let a={},s=[],c=[`Source: ${e.basename(i.file)}.`];if(i.json)l(JSON.parse(r.readFileSync(i.file,`utf-8`).replace(/^\uFEFF/,``)).rules,a,s);else if(t.online&&t.write){let e=await d(t.cwd);e?(l(e.rules,a,s),c.push("Rules evaluated with `@oxlint/migrate` (online).")):c.push("`@oxlint/migrate` did not produce `.oxlintrc.json`; hand-map the rules.")}else t.online?c.push("Flat config: online evaluation runs `@oxlint/migrate`, which writes `.oxlintrc.json` — re-run with `--write`."):c.push("Flat config detected — re-run with `--online --write` to use `@oxlint/migrate`, or hand-map the rules.");let u={$schema:`./node_modules/oxlint/configuration_schema.json`,rules:a};if((t.target??`files`)===`vite`){let e=n(t.cwd,{lint:u});return t.write&&r.writeFileSync(e.path,e.content,`utf-8`),{id:f.id,from:`eslint`,to:`oxlint`,written:[e.path],files:[e],oxlint:u,unmapped:s,notes:[...c,"Folded into vite.config.ts (`lint`)."]}}let p={path:e.join(t.cwd,`.oxlintrc.json`),content:`${JSON.stringify(u,null,4)}\n`};return t.write&&r.writeFileSync(p.path,p.content,`utf-8`),{id:f.id,from:`eslint`,to:`oxlint`,written:[p.path],files:[p],oxlint:u,unmapped:s,notes:c}}};export{f as eslintToOx,o as findEslintConfig,c as mapRuleName,d as runOxlintMigrate};

package/dist/packages/migrate/src/index.d.ts

@@ -0,0 +1,14 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { MigrateTarget, MigrateTool, MigrationContext, MigrationFile, MigrationResult, ToolingMigration, UnmappedItem } from "./types.js";
+import { BIOME_CONFIG_FILES, biomeToOx, findBiomeConfig, readJsonc, stripJsonc } from "./biome.js";
+import { FileDiff, FileStatus, diffFiles, hasPending } from "./check.js";
+import { migrateCommands } from "./cli/index.js";
+import { dprintToOx, findDprintConfig, mapDprintToOxfmt } from "./dprint.js";
+import { eslintToOx, findEslintConfig, mapRuleName, runOxlintMigrate } from "./eslint.js";
+import { DEFAULT_IGNORE, OxfmtMapping, mapBiomeFormatter, mapBiomeIncludes, mapBiomeToOxfmt, mapOrganizeImports } from "./oxfmt-map.js";
+import { OxlintMapping, RULE_MAP, mapBiomeToOxlint } from "./oxlint-map.js";
+import { findPrettierConfig, mapPrettierToOxfmt, prettierToOx, readPrettierIgnore } from "./prettier.js";
+import { MigrationInfo, detectMigrations, findMigration, listMigrations, migrations, runDetectedMigrations, runMigration } from "./registry.js";
+import { findTopLevelValue, matchBracket, mergeViteConfig, renderViteTarget, serializeTs, writeViteTarget } from "./vite-target.js";
+export { BIOME_CONFIG_FILES, DEFAULT_IGNORE, FileDiff, FileStatus, MigrateTarget, MigrateTool, MigrationContext, MigrationFile, MigrationInfo, MigrationResult, OxfmtMapping, OxlintMapping, RULE_MAP, ToolingMigration, UnmappedItem, biomeToOx, detectMigrations, diffFiles, dprintToOx, eslintToOx, findBiomeConfig, findDprintConfig, findEslintConfig, findMigration, findPrettierConfig, findTopLevelValue, hasPending, listMigrations, mapBiomeFormatter, mapBiomeIncludes, mapBiomeToOxfmt, mapBiomeToOxlint, mapDprintToOxfmt, mapOrganizeImports, mapPrettierToOxfmt, mapRuleName, matchBracket, mergeViteConfig, migrateCommands, migrations, prettierToOx, readJsonc, readPrettierIgnore, renderViteTarget, runDetectedMigrations, runMigration, runOxlintMigrate, serializeTs, stripJsonc, writeViteTarget };

package/dist/packages/migrate/src/index.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{diffFiles as e,hasPending as t}from"./check.js";import{DEFAULT_IGNORE as n,mapBiomeFormatter as r,mapBiomeIncludes as i,mapBiomeToOxfmt as a,mapOrganizeImports as o}from"./oxfmt-map.js";import{RULE_MAP as s,mapBiomeToOxlint as c}from"./oxlint-map.js";import{findTopLevelValue as l,matchBracket as u,mergeViteConfig as d,renderViteTarget as f,serializeTs as p,writeViteTarget as m}from"./vite-target.js";import{BIOME_CONFIG_FILES as h,biomeToOx as g,findBiomeConfig as _,readJsonc as v,stripJsonc as y}from"./biome.js";import{dprintToOx as b,findDprintConfig as x,mapDprintToOxfmt as S}from"./dprint.js";import{eslintToOx as C,findEslintConfig as w,mapRuleName as T,runOxlintMigrate as E}from"./eslint.js";import{findPrettierConfig as D,mapPrettierToOxfmt as O,prettierToOx as k,readPrettierIgnore as A}from"./prettier.js";import{detectMigrations as j,findMigration as M,listMigrations as N,migrations as P,runDetectedMigrations as F,runMigration as I}from"./registry.js";import{migrateCommands as L}from"./cli/index.js";export{h as BIOME_CONFIG_FILES,n as DEFAULT_IGNORE,s as RULE_MAP,g as biomeToOx,j as detectMigrations,e as diffFiles,b as dprintToOx,C as eslintToOx,_ as findBiomeConfig,x as findDprintConfig,w as findEslintConfig,M as findMigration,D as findPrettierConfig,l as findTopLevelValue,t as hasPending,N as listMigrations,r as mapBiomeFormatter,i as mapBiomeIncludes,a as mapBiomeToOxfmt,c as mapBiomeToOxlint,S as mapDprintToOxfmt,o as mapOrganizeImports,O as mapPrettierToOxfmt,T as mapRuleName,u as matchBracket,d as mergeViteConfig,L as migrateCommands,P as migrations,k as prettierToOx,v as readJsonc,A as readPrettierIgnore,f as renderViteTarget,F as runDetectedMigrations,I as runMigration,E as runOxlintMigrate,p as serializeTs,y as stripJsonc,m as writeViteTarget};