@ankhorage/devtools 1.2.1 → 1.3.1

package/dist/tools/eslint/index.js

@@ -1,10 +1,36 @@
+/***
+ * Create the shared strict ESLint flat configuration used by consuming repositories.
+ *
+ * The default `profile: 'auto'` reads the nearest `package.json` from `tsconfigRootDir` and uses
+ * `@ankhorage/utility/project` to select overlapping project traits. React Native and Expo select
+ * the `react-native` profile, React and Next.js select `react`, and other projects use `base`.
+ * Consumers can explicitly select `base`, `react`, or `react-native` when automatic detection is
+ * not appropriate.
+ *
+ * Every profile includes the shared TypeScript, import, unused-import, Prettier, security, and
+ * quality rules. The common quality limits are 50 effective lines per function, 300 effective
+ * lines per file, and modified cyclomatic complexity 15. React adds React and Hooks correctness
+ * rules; React Native composes the React profile and adds focused React Native rules.
+ *
+ * Repository-specific behavior stays additive: `additionalIgnores`, `restrictedImports`, and
+ * `overrides` extend the central policy instead of replacing it. Narrow local overrides remain the
+ * supported migration mechanism for legacy violations while organization-wide defaults stay
+ * strict.
+ *
+ * @readme
+ */
 import js from '@eslint/js';
 import prettierConfig from 'eslint-config-prettier';
 import importPlugin from 'eslint-plugin-import';
 import prettierPlugin from 'eslint-plugin-prettier';
+import reactPlugin from 'eslint-plugin-react';
+import reactHooksPlugin from 'eslint-plugin-react-hooks';
+import reactNativePlugin from 'eslint-plugin-react-native';
+import securityPlugin from 'eslint-plugin-security';
 import simpleImportSort from 'eslint-plugin-simple-import-sort';
 import unusedImports from 'eslint-plugin-unused-imports';
 import tseslint from 'typescript-eslint';
+import { resolveEslintProfile } from './profile.js';
 export const defaultIgnores = [
     '**/ios/**',
     '**/android/**',
@@ -24,79 +50,138 @@ export const defaultRestrictedImports = [
     },
 ];
 export function createConfig(options) {
-    const normalizedOptions = {
-        allowDefaultProject: [],
-        additionalIgnores: [],
-        restrictedImports: [],
-        overrides: [],
-        includePrettier: true,
-        ...options,
+    const normalized = normalizeOptions(options);
+    const profile = resolveEslintProfile(options);
+    return tseslint.config({ ignores: [...defaultIgnores, ...normalized.additionalIgnores] }, js.configs.recommended, ...createTypeCheckedConfigs(normalized), createBaseConfig(normalized), ...createProfileConfigs(profile, normalized.files), ...normalized.overrides, ...(normalized.includePrettier ? [prettierConfig] : []));
+}
+function normalizeOptions(options) {
+    return {
+        tsconfigRootDir: options.tsconfigRootDir,
+        project: options.project,
+        files: options.files,
+        allowDefaultProject: options.allowDefaultProject ?? [],
+        additionalIgnores: options.additionalIgnores ?? [],
+        restrictedImports: [...(options.restrictedImports ?? [])],
+        overrides: [...(options.overrides ?? [])],
+        includePrettier: options.includePrettier ?? true,
     };
-    const combinedRestrictedImports = [
-        ...defaultRestrictedImports,
-        ...normalizedOptions.restrictedImports,
+}
+function createTypeCheckedConfigs(options) {
+    const configs = [
+        ...tseslint.configs.recommendedTypeChecked,
+        ...tseslint.configs.stylisticTypeChecked,
     ];
-    const plugins = {
-        import: importPlugin,
-        prettier: prettierPlugin,
-        'simple-import-sort': simpleImportSort,
-        'unused-imports': unusedImports,
-    };
-    return tseslint.config({
-        ignores: [...defaultIgnores, ...normalizedOptions.additionalIgnores],
-    }, js.configs.recommended, ...tseslint.configs.recommendedTypeChecked.map((config) => ({
-        ...config,
-        files: normalizedOptions.files,
-    })), ...tseslint.configs.stylisticTypeChecked.map((config) => ({
-        ...config,
-        files: normalizedOptions.files,
-    })), {
-        files: normalizedOptions.files,
+    return configs.map((config) => ({ ...config, files: options.files }));
+}
+function createBaseConfig(options) {
+    return {
+        files: options.files,
         languageOptions: {
             parser: tseslint.parser,
             parserOptions: {
-                project: normalizedOptions.project,
-                tsconfigRootDir: normalizedOptions.tsconfigRootDir,
-                allowDefaultProject: normalizedOptions.allowDefaultProject,
+                project: options.project,
+                tsconfigRootDir: options.tsconfigRootDir,
+                allowDefaultProject: options.allowDefaultProject,
+                ecmaFeatures: { jsx: true },
             },
         },
-        plugins,
+        plugins: {
+            import: importPlugin,
+            prettier: prettierPlugin,
+            security: securityPlugin,
+            'simple-import-sort': simpleImportSort,
+            'unused-imports': unusedImports,
+        },
         rules: {
-            '@typescript-eslint/no-non-null-assertion': 'error',
-            '@typescript-eslint/prefer-readonly': 'error',
-            '@typescript-eslint/prefer-optional-chain': 'error',
-            '@typescript-eslint/prefer-as-const': 'error',
-            '@typescript-eslint/no-unnecessary-type-arguments': 'error',
-            '@typescript-eslint/no-unnecessary-condition': 'error',
-            '@typescript-eslint/no-unnecessary-type-constraint': 'error',
-            '@typescript-eslint/consistent-type-imports': ['error', { prefer: 'type-imports' }],
-            '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
-            '@typescript-eslint/prefer-nullish-coalescing': 'error',
-            'no-restricted-imports': [
-                'error',
-                {
-                    paths: combinedRestrictedImports,
-                },
-            ],
-            'prefer-destructuring': 'off',
-            '@typescript-eslint/prefer-destructuring': 'error',
-            'simple-import-sort/imports': 'error',
-            'simple-import-sort/exports': 'error',
-            'unused-imports/no-unused-imports': 'error',
-            'unused-imports/no-unused-vars': [
-                'error',
-                {
-                    vars: 'all',
-                    varsIgnorePattern: '^_',
-                    args: 'after-used',
-                    argsIgnorePattern: '^_',
-                },
-            ],
-            'import/order': 'off',
-            '@typescript-eslint/no-unused-vars': 'off',
-            '@typescript-eslint/no-explicit-any': 'error',
-            'prettier/prettier': 'error',
-            'no-console': 'off',
+            ...createTypeScriptRules(),
+            ...createImportRules(options),
+            ...createQualityRules(),
+            ...createSecurityRules(),
         },
-    }, ...normalizedOptions.overrides, ...(normalizedOptions.includePrettier ? [prettierConfig] : []));
+    };
+}
+function createTypeScriptRules() {
+    return {
+        '@typescript-eslint/no-non-null-assertion': 'error',
+        '@typescript-eslint/prefer-readonly': 'error',
+        '@typescript-eslint/prefer-optional-chain': 'error',
+        '@typescript-eslint/prefer-as-const': 'error',
+        '@typescript-eslint/no-unnecessary-type-arguments': 'error',
+        '@typescript-eslint/no-unnecessary-condition': 'error',
+        '@typescript-eslint/no-unnecessary-type-constraint': 'error',
+        '@typescript-eslint/consistent-type-imports': ['error', { prefer: 'type-imports' }],
+        '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
+        '@typescript-eslint/prefer-nullish-coalescing': 'error',
+        '@typescript-eslint/prefer-destructuring': 'error',
+        '@typescript-eslint/no-unused-vars': 'off',
+        '@typescript-eslint/no-explicit-any': 'error',
+    };
+}
+function createImportRules(options) {
+    return {
+        'no-restricted-imports': [
+            'error',
+            { paths: [...defaultRestrictedImports, ...options.restrictedImports] },
+        ],
+        'prefer-destructuring': 'off',
+        'simple-import-sort/imports': 'error',
+        'simple-import-sort/exports': 'error',
+        'unused-imports/no-unused-imports': 'error',
+        'unused-imports/no-unused-vars': [
+            'error',
+            { vars: 'all', varsIgnorePattern: '^_', args: 'after-used', argsIgnorePattern: '^_' },
+        ],
+        'import/order': 'off',
+        'prettier/prettier': 'error',
+        'no-console': 'off',
+    };
+}
+function createQualityRules() {
+    return {
+        'max-lines-per-function': ['error', { max: 50, skipBlankLines: true, skipComments: true }],
+        'max-lines': ['error', { max: 300, skipBlankLines: true, skipComments: true }],
+        complexity: ['error', { max: 15, variant: 'modified' }],
+    };
+}
+function createSecurityRules() {
+    return {
+        'security/detect-object-injection': 'warn',
+        'security/detect-non-literal-require': 'error',
+    };
+}
+function createProfileConfigs(profile, files) {
+    if (profile === 'base') {
+        return [];
+    }
+    const reactConfig = createReactConfig(files);
+    return profile === 'react-native' ? [reactConfig, createReactNativeConfig(files)] : [reactConfig];
+}
+function createReactConfig(files) {
+    return {
+        files,
+        plugins: { react: reactPlugin, 'react-hooks': reactHooksPlugin },
+        settings: { react: { version: 'detect' } },
+        rules: {
+            'react/no-danger': 'error',
+            'react-hooks/rules-of-hooks': 'error',
+            'react-hooks/exhaustive-deps': 'error',
+            'react-hooks/immutability': 'error',
+            'react-hooks/purity': 'error',
+            'react-hooks/refs': 'error',
+            'react-hooks/set-state-in-effect': 'error',
+            'react-hooks/set-state-in-render': 'error',
+            'react-hooks/static-components': 'error',
+        },
+    };
+}
+function createReactNativeConfig(files) {
+    return {
+        files,
+        plugins: { 'react-native': reactNativePlugin },
+        rules: {
+            'react-native/no-inline-styles': 'warn',
+            'react-native/no-unused-styles': 'error',
+            'react-native/no-single-element-style-arrays': 'error',
+        },
+    };
 }

package/dist/tools/eslint/managed.d.ts

@@ -0,0 +1,10 @@
+export declare const eslintManagedFiles: readonly [{
+    readonly relativePath: "eslint.local.config.mjs";
+    readonly render: typeof renderInitialLocalConfig;
+    readonly mode: "create-only";
+}, {
+    readonly relativePath: "eslint.config.mjs";
+    readonly contents: "import { createConfig } from '@ankhorage/devtools/eslint';\nimport localConfig from './eslint.local.config.mjs';\n\nconst localEntries = Array.isArray(localConfig) ? localConfig : [localConfig];\n\nexport default [\n  ...createConfig({\n    files: ['src/**/*.{ts,tsx}'],\n    project: ['./tsconfig.json'],\n    tsconfigRootDir: import.meta.dirname,\n  }),\n  ...localEntries,\n];\n";
+}];
+declare function renderInitialLocalConfig(targetDirectory: string): Promise<string>;
+export {};

package/dist/tools/eslint/managed.js

@@ -0,0 +1,44 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+const ESLINT_CONFIG = `import { createConfig } from '@ankhorage/devtools/eslint';
+import localConfig from './eslint.local.config.mjs';
+
+const localEntries = Array.isArray(localConfig) ? localConfig : [localConfig];
+
+export default [
+  ...createConfig({
+    files: ['src/**/*.{ts,tsx}'],
+    project: ['./tsconfig.json'],
+    tsconfigRootDir: import.meta.dirname,
+  }),
+  ...localEntries,
+];
+`;
+const EMPTY_LOCAL_CONFIG = `export default [];
+`;
+export const eslintManagedFiles = [
+    {
+        relativePath: 'eslint.local.config.mjs',
+        render: renderInitialLocalConfig,
+        mode: 'create-only',
+    },
+    {
+        relativePath: 'eslint.config.mjs',
+        contents: ESLINT_CONFIG,
+    },
+];
+async function renderInitialLocalConfig(targetDirectory) {
+    try {
+        const existingConfig = await readFile(resolve(targetDirectory, 'eslint.config.mjs'), 'utf8');
+        return existingConfig === ESLINT_CONFIG ? EMPTY_LOCAL_CONFIG : existingConfig;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return EMPTY_LOCAL_CONFIG;
+        }
+        throw error;
+    }
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}

package/dist/tools/eslint/profile.d.ts

@@ -0,0 +1,4 @@
+import { type ProjectDetectionInput } from '@ankhorage/utility/project';
+import type { DevtoolsConfigOptions, DevtoolsEslintProfile, ResolvedDevtoolsEslintProfile } from './types.js';
+export declare function resolveEslintProfile(options: DevtoolsConfigOptions): ResolvedDevtoolsEslintProfile;
+export declare function resolveEslintProfileFromDetectionInput(requestedProfile: DevtoolsEslintProfile, input: ProjectDetectionInput): ResolvedDevtoolsEslintProfile;

package/dist/tools/eslint/profile.js

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { detectProject, } from '@ankhorage/utility/project';
+export function resolveEslintProfile(options) {
+    const requestedProfile = options.profile ?? 'auto';
+    if (requestedProfile !== 'auto') {
+        return requestedProfile;
+    }
+    const packageJsonPath = resolveProjectPackageJsonPath(options);
+    const input = packageJsonPath === null ? {} : readDetectionInput(packageJsonPath);
+    return resolveEslintProfileFromDetectionInput('auto', input);
+}
+export function resolveEslintProfileFromDetectionInput(requestedProfile, input) {
+    if (requestedProfile !== 'auto') {
+        return requestedProfile;
+    }
+    const { traits } = detectProject(input);
+    if (traits.has('react-native') || traits.has('expo')) {
+        return 'react-native';
+    }
+    return traits.has('react') ? 'react' : 'base';
+}
+function resolveProjectPackageJsonPath(options) {
+    if (options.packageJsonPath !== undefined) {
+        return resolve(options.tsconfigRootDir, options.packageJsonPath);
+    }
+    let directory = resolve(options.tsconfigRootDir);
+    for (;;) {
+        const candidate = resolve(directory, 'package.json');
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = dirname(directory);
+        if (parent === directory) {
+            return null;
+        }
+        directory = parent;
+    }
+}
+function readDetectionInput(packageJsonPath) {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    if (!isRecord(parsed)) {
+        throw new Error(`Expected package.json to contain a JSON object: ${packageJsonPath}`);
+    }
+    return {
+        ...optionalDependencyMap('dependencies', parsed.dependencies),
+        ...optionalDependencyMap('devDependencies', parsed.devDependencies),
+        ...optionalDependencyMap('peerDependencies', parsed.peerDependencies),
+        ...optionalEngines(parsed.engines),
+        ...(typeof parsed.packageManager === 'string' ? { packageManager: parsed.packageManager } : {}),
+    };
+}
+function optionalDependencyMap(key, value) {
+    const dependencyMap = toDependencyMap(value);
+    return dependencyMap === undefined ? {} : { [key]: dependencyMap };
+}
+function toDependencyMap(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const dependencies = {};
+    for (const [name, version] of Object.entries(value)) {
+        if (typeof version === 'string') {
+            dependencies[name] = version;
+        }
+    }
+    return dependencies;
+}
+function optionalEngines(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    const engines = {
+        ...(typeof value.bun === 'string' ? { bun: value.bun } : {}),
+        ...(typeof value.node === 'string' ? { node: value.node } : {}),
+    };
+    return Object.keys(engines).length === 0 ? {} : { engines };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/tools/eslint/types.d.ts

@@ -1,14 +1,18 @@
 import type tseslint from 'typescript-eslint';
 type FlatConfig = ReturnType<typeof tseslint.config>;
 export type FlatConfigItem = FlatConfig[number];
-interface RestrictedImport {
+export interface RestrictedImport {
     readonly name: string;
     readonly message: string;
 }
+export type DevtoolsEslintProfile = 'auto' | 'base' | 'react' | 'react-native';
+export type ResolvedDevtoolsEslintProfile = Exclude<DevtoolsEslintProfile, 'auto'>;
 export interface DevtoolsConfigOptions {
     readonly tsconfigRootDir: string;
     readonly project: string[];
     readonly files: string[];
+    readonly profile?: DevtoolsEslintProfile;
+    readonly packageJsonPath?: string;
     readonly allowDefaultProject?: string[];
     readonly additionalIgnores?: string[];
     readonly restrictedImports?: RestrictedImport[];

package/dist/tools/knip/index.d.ts

@@ -1,3 +1,16 @@
+/***
+ * Build shared Knip configuration while preserving repository-specific discovery.
+ *
+ * `createKnipConfig` keeps Knip zero-config behavior by default and only emits settings that the
+ * consumer explicitly provides. Repositories can add narrow entries, project globs, ignored files,
+ * binaries, dependencies, and workspace overrides without duplicating the shared Knip version.
+ *
+ * `createKnipMonorepoConfig` adds a root workspace plus conventional `packages/*` and `apps/*`
+ * workspace globs. Callers can override those globs, provide workspace defaults, and replace or
+ * extend individual workspace configuration deterministically.
+ *
+ * @readme
+ */
 import type { KnipConfig } from 'knip';
 export interface DevtoolsKnipWorkspaceConfigOptions {
     readonly entry?: string[];

package/dist/tools/knip/managed.d.ts

@@ -0,0 +1,5 @@
+export declare const knipManagedFiles: readonly [{
+    readonly relativePath: "knip.config.ts";
+    readonly contents: "import { createKnipConfig } from '@ankhorage/devtools/knip';\n\nexport default createKnipConfig();\n";
+    readonly mode: "create-only";
+}];

package/dist/tools/knip/managed.js

@@ -0,0 +1,11 @@
+const KNIP_CONFIG = `import { createKnipConfig } from '@ankhorage/devtools/knip';
+
+export default createKnipConfig();
+`;
+export const knipManagedFiles = [
+    {
+        relativePath: 'knip.config.ts',
+        contents: KNIP_CONFIG,
+        mode: 'create-only',
+    },
+];

package/dist/tools/package/index.d.ts

@@ -0,0 +1,8 @@
+import type { ManagedFileStatus, ManagedFileSyncResult } from '../shared/managedFiles.js';
+export declare function inspectPackageManifest(targetDirectory: string, devtoolsVersion: string): Promise<ManagedFileStatus>;
+export declare function syncPackageManifest(targetDirectory: string, devtoolsVersion: string, options: {
+    readonly dryRun: boolean;
+}): Promise<ManagedFileSyncResult>;
+export declare function applyManagedPackageContract(manifest: Record<string, unknown>, devtoolsVersion: string): Record<string, unknown>;
+export declare function isManagedPackageContractCurrent(manifest: Record<string, unknown>, devtoolsVersion: string): boolean;
+export declare function readCurrentDevtoolsVersion(): string;

package/dist/tools/package/index.js

@@ -0,0 +1,172 @@
+/***
+ * Synchronize the consumer `package.json` contract owned by `@ankhorage/devtools`.
+ *
+ * Package synchronization is merge-aware. It installs the current `@ankhorage/devtools` version
+ * as a development dependency for normal consumers, while `@ankhorage/ankh` keeps devtools as a
+ * runtime dependency because the CLI loads it as a bundled core provider. Individually installed
+ * toolchain packages that devtools now owns are removed, and the canonical `lint`, `lint:fix`,
+ * `format`, `format:check`, and `knip` scripts are written.
+ * Unrelated manifest fields, scripts, dependencies, and metadata are preserved.
+ *
+ * Status compares only the fields owned by this contract, so unrelated repository customization
+ * does not count as drift. `--dry-run` reports whether `package.json` would be created or updated
+ * without writing it, and repeated synchronization is idempotent.
+ *
+ * The devtools package itself is excluded from the consumer contract to avoid rewriting its own
+ * manifest.
+ *
+ * @readme
+ */
+import { readFileSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+const PACKAGE_PATH = 'package.json';
+const DEVTOOLS_PACKAGE_NAME = '@ankhorage/devtools';
+const ANKH_PACKAGE_NAME = '@ankhorage/ankh';
+const STANDARD_SCRIPTS = {
+    lint: 'ankhorage-eslint . --max-warnings=0',
+    'lint:fix': 'ankhorage-eslint . --fix --max-warnings=0',
+    format: 'ankhorage-prettier --write .',
+    'format:check': 'ankhorage-prettier --check .',
+    knip: 'ankhorage-knip',
+};
+const DEVTOOLS_OWNED_DEV_DEPENDENCIES = [
+    '@eslint/js',
+    'eslint',
+    'eslint-config-prettier',
+    'eslint-plugin-import',
+    'eslint-plugin-prettier',
+    'eslint-plugin-react',
+    'eslint-plugin-react-hooks',
+    'eslint-plugin-react-native',
+    'eslint-plugin-security',
+    'eslint-plugin-simple-import-sort',
+    'eslint-plugin-unused-imports',
+    'knip',
+    'prettier',
+    'typescript-eslint',
+];
+export async function inspectPackageManifest(targetDirectory, devtoolsVersion) {
+    const snapshot = await readPackageManifest(targetDirectory);
+    if (!snapshot.exists) {
+        return { relativePath: PACKAGE_PATH, state: 'missing' };
+    }
+    return {
+        relativePath: PACKAGE_PATH,
+        state: isManagedPackageContractCurrent(snapshot.manifest, devtoolsVersion)
+            ? 'current'
+            : 'outdated',
+    };
+}
+export async function syncPackageManifest(targetDirectory, devtoolsVersion, options) {
+    const snapshot = await readPackageManifest(targetDirectory);
+    if (snapshot.exists && isManagedPackageContractCurrent(snapshot.manifest, devtoolsVersion)) {
+        return { relativePath: PACKAGE_PATH, action: 'unchanged' };
+    }
+    if (options.dryRun) {
+        return {
+            relativePath: PACKAGE_PATH,
+            action: snapshot.exists ? 'would-update' : 'would-create',
+        };
+    }
+    const updatedManifest = applyManagedPackageContract(snapshot.manifest, devtoolsVersion);
+    await writeFile(resolve(targetDirectory, PACKAGE_PATH), serializePackageManifest(updatedManifest), 'utf8');
+    return {
+        relativePath: PACKAGE_PATH,
+        action: snapshot.exists ? 'updated' : 'created',
+    };
+}
+export function applyManagedPackageContract(manifest, devtoolsVersion) {
+    if (manifest.name === DEVTOOLS_PACKAGE_NAME) {
+        return manifest;
+    }
+    const scripts = { ...toRecord(manifest.scripts), ...STANDARD_SCRIPTS };
+    const devDependencies = removeOwnedDependencies(toRecord(manifest.devDependencies));
+    const dependencies = toRecord(manifest.dependencies);
+    applyDevtoolsDependencyPlacement(manifest, dependencies, devDependencies, devtoolsVersion);
+    return {
+        ...manifest,
+        ...normalizedDependencies(manifest, dependencies),
+        scripts,
+        devDependencies,
+    };
+}
+export function isManagedPackageContractCurrent(manifest, devtoolsVersion) {
+    if (manifest.name === DEVTOOLS_PACKAGE_NAME) {
+        return true;
+    }
+    const scripts = toRecord(manifest.scripts);
+    const devDependencies = toRecord(manifest.devDependencies);
+    const dependencies = toRecord(manifest.dependencies);
+    return (hasStandardScripts(scripts) &&
+        DEVTOOLS_OWNED_DEV_DEPENDENCIES.every((name) => devDependencies[name] === undefined) &&
+        hasCurrentDevtoolsDependencyPlacement(manifest, dependencies, devDependencies, devtoolsVersion));
+}
+export function readCurrentDevtoolsVersion() {
+    const parsed = JSON.parse(readFileSync(new URL('../../../package.json', import.meta.url), 'utf8'));
+    if (!isRecord(parsed) || typeof parsed.version !== 'string' || parsed.version.trim() === '') {
+        throw new Error('Devtools package.json must define a non-empty version string.');
+    }
+    return parsed.version;
+}
+async function readPackageManifest(targetDirectory) {
+    try {
+        const contents = await readFile(resolve(targetDirectory, PACKAGE_PATH), 'utf8');
+        const parsed = JSON.parse(contents);
+        if (!isRecord(parsed)) {
+            throw new Error(`Expected ${PACKAGE_PATH} to contain a JSON object.`);
+        }
+        return { exists: true, manifest: parsed };
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return { exists: false, manifest: {} };
+        }
+        throw error;
+    }
+}
+function applyDevtoolsDependencyPlacement(manifest, dependencies, devDependencies, devtoolsVersion) {
+    const versionRange = `^${devtoolsVersion}`;
+    if (manifest.name === ANKH_PACKAGE_NAME) {
+        dependencies[DEVTOOLS_PACKAGE_NAME] = versionRange;
+        delete devDependencies[DEVTOOLS_PACKAGE_NAME];
+        return;
+    }
+    devDependencies[DEVTOOLS_PACKAGE_NAME] = versionRange;
+    delete dependencies[DEVTOOLS_PACKAGE_NAME];
+}
+function hasCurrentDevtoolsDependencyPlacement(manifest, dependencies, devDependencies, devtoolsVersion) {
+    const versionRange = `^${devtoolsVersion}`;
+    if (manifest.name === ANKH_PACKAGE_NAME) {
+        return (dependencies[DEVTOOLS_PACKAGE_NAME] === versionRange &&
+            devDependencies[DEVTOOLS_PACKAGE_NAME] === undefined);
+    }
+    return (devDependencies[DEVTOOLS_PACKAGE_NAME] === versionRange &&
+        dependencies[DEVTOOLS_PACKAGE_NAME] === undefined);
+}
+function removeOwnedDependencies(devDependencies) {
+    for (const dependencyName of DEVTOOLS_OWNED_DEV_DEPENDENCIES) {
+        delete devDependencies[dependencyName];
+    }
+    return devDependencies;
+}
+function normalizedDependencies(manifest, dependencies) {
+    return Object.keys(dependencies).length === 0 && manifest.dependencies === undefined
+        ? {}
+        : { dependencies };
+}
+function hasStandardScripts(scripts) {
+    return Object.entries(STANDARD_SCRIPTS).every(([name, command]) => scripts[name] === command);
+}
+function serializePackageManifest(manifest) {
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+function toRecord(value) {
+    return isRecord(value) ? { ...value } : {};
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}

package/dist/tools/prettier/managed.d.ts

@@ -0,0 +1,6 @@
+export declare const prettierManagedFiles: readonly [{
+    readonly relativePath: ".prettierrc.js";
+    readonly render: typeof renderPrettierConfig;
+}];
+declare function renderPrettierConfig(targetDirectory: string): Promise<string>;
+export {};

package/dist/tools/prettier/managed.js

@@ -0,0 +1,34 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+const ESM_CONFIG = `export { default } from '@ankhorage/devtools/prettier';
+`;
+const COMMONJS_CONFIG = `module.exports = require('@ankhorage/devtools/prettier');
+`;
+export const prettierManagedFiles = [
+    {
+        relativePath: '.prettierrc.js',
+        render: renderPrettierConfig,
+    },
+];
+async function renderPrettierConfig(targetDirectory) {
+    return (await readPackageType(targetDirectory)) === 'module' ? ESM_CONFIG : COMMONJS_CONFIG;
+}
+async function readPackageType(targetDirectory) {
+    try {
+        const contents = await readFile(resolve(targetDirectory, 'package.json'), 'utf8');
+        const parsed = JSON.parse(contents);
+        return isRecord(parsed) && typeof parsed.type === 'string' ? parsed.type : undefined;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}