@ankhorage/devtools 1.2.0 → 1.3.0

package/README.md

@@ -4,7 +4,7 @@ Shared development tools and repository standards for Ankhorage TypeScript proje
 
 ## What it owns
 
-`@ankhorage/devtools` is the single source of truth for these equal, separate concerns:
+`@ankhorage/devtools` is the single source of truth for these separate concerns:
 
 ```text
 src/
@@ -13,25 +13,39 @@ src/
     ├── eslint/
     ├── prettier/
     ├── knip/
+    ├── package/
     ├── workflows/
     └── vscode/
 ```
 
-- `eslint`: shared flat ESLint configuration and the bundled ESLint runner
+- `eslint`: shared flat ESLint configuration, automatic project profiles, and the bundled ESLint runner
 - `prettier`: shared Prettier configuration and the bundled Prettier runner
-- `knip`: shared Knip configuration and the bundled Knip runner
+- `knip`: shared Knip configuration helpers and the bundled Knip runner
+- `package`: merge-aware synchronization of the shared `package.json` tooling contract
 - `workflows`: canonical `.github/workflows/ci.yml` and `release.yml`
 - `vscode`: canonical `.vscode/settings.json` and `extensions.json`
 
-There is no generic template layer around these concerns. Each tool owns its canonical files and behavior.
+The package owns the supported ESLint, TypeScript ESLint, Prettier, Knip, security, React, React Hooks, React Native, import/sort, unused-import, and formatting-plugin versions used by consuming repositories.
 
-## Installation
+## Bootstrap
+
+For a repository that does not yet depend on the shared toolchain:
 
 ```bash
 bun add -D @ankhorage/devtools
+bunx @ankhorage/ankh devtools sync .
+bun install
+```
+
+After the first install, the normal workflow is:
+
+```bash
+ankh devtools sync
 ```
 
-The package owns the ESLint, Prettier, and Knip versions used by consuming repositories. Do not install those tools directly unless a repository intentionally opts out of the shared Ankhorage toolchain.
+The target path is optional and defaults to the current working directory.
+
+Synchronization ensures `@ankhorage/devtools` is declared using the version of the provider performing the sync, installs the standard package scripts, and removes direct devDependencies for tools/plugins owned by devtools. Unrelated package metadata, dependencies, and scripts are preserved.
 
 ## Ankh provider
 
@@ -42,6 +56,14 @@ The package is discovered under the `devtools` category and exposes these capabi
 - `devtools.knip`
 - `devtools.sync`
 - `devtools.status`
+- `devtools.eslint.sync`
+- `devtools.eslint.status`
+- `devtools.prettier.sync`
+- `devtools.prettier.status`
+- `devtools.knip.sync`
+- `devtools.knip.status`
+- `devtools.package.sync`
+- `devtools.package.status`
 - `devtools.workflows.sync`
 - `devtools.workflows.status`
 - `devtools.vscode.sync`
@@ -61,13 +83,13 @@ ankh devtools format -- --check .
 ankh devtools knip -- --production
 ```
 
-These commands delegate to the same bundled tools as the package binaries:
+These delegate to the same bundled tools as the package binaries:
 
 - `ankh devtools lint` → `ankhorage-eslint`
 - `ankh devtools format` → `ankhorage-prettier`
 - `ankh devtools knip` → `ankhorage-knip`
 
-Recommended package scripts:
+The synchronized package scripts are:
 
 ```json
 {
@@ -83,159 +105,184 @@ Recommended package scripts:
 
 ## Repository synchronization
 
-### Synchronize all managed files
+Synchronize or inspect every managed concern:
 
 ```bash
 ankh devtools sync .
-```
-
-The target path is optional and defaults to the current working directory:
-
-```bash
-ankh devtools sync
-```
-
-### Report drift without changing files
-
-```bash
 ankh devtools status .
 ```
 
-`status` exits with code `1` when any managed file is missing or outdated. It exits with code `0` when all managed files are current.
-
-Example output:
-
-```text
-✓ .github/workflows/ci.yml
-✗ .github/workflows/release.yml outdated
-+ .vscode/settings.json missing
-✓ .vscode/extensions.json
-```
-
-### Synchronize one concern
+Synchronize one concern:
 
 ```bash
+ankh devtools eslint sync .
+ankh devtools prettier sync .
+ankh devtools knip sync .
+ankh devtools package sync .
 ankh devtools workflows sync .
 ankh devtools vscode sync .
 ```
 
-### Report one concern
+Report one concern:
 
 ```bash
+ankh devtools eslint status .
+ankh devtools prettier status .
+ankh devtools knip status .
+ankh devtools package status .
 ankh devtools workflows status .
 ankh devtools vscode status .
 ```
 
-### Preview synchronization
+Preview synchronization without writing:
 
 ```bash
 ankh devtools sync . --dry-run
-ankh devtools workflows sync . --dry-run
-ankh devtools vscode sync . --dry-run
+ankh devtools eslint sync . --dry-run
+ankh devtools package sync . --dry-run
 ```
 
-A dry run reports `would create` and `would update` actions without writing any files.
+A dry run reports `would create` and `would update` actions without mutating files. `status` exits with code `1` when managed state has drifted and `0` when it is current.
 
 ## Synchronization guarantees
 
 Synchronization is deterministic and idempotent:
 
-- missing managed files are created
-- outdated managed files are replaced with the canonical package version
-- current managed files are left untouched
-- unrelated files are never modified
-- unknown files in `.github/workflows` and `.vscode` are never deleted
-- repeating `sync` after a successful run produces only `unchanged` results
+- missing managed artifacts are created
+- outdated centrally owned artifacts are updated
+- current artifacts are left untouched
+- unrelated files and package fields are preserved
+- repeated sync produces only `unchanged` results
 - invalid target paths and write failures return a non-zero exit code
+- create-only repository extension files are never overwritten after creation
 
-The canonical files are packaged with `@ankhorage/devtools`; synchronization does not fetch mutable files from GitHub at runtime.
-
-## Managed GitHub Actions workflows
-
-`workflows` owns exactly:
-
-```text
-.github/workflows/ci.yml
-.github/workflows/release.yml
-```
+The canonical workflow and VS Code files are packaged with `@ankhorage/devtools`; synchronization does not fetch mutable files from GitHub at runtime.
 
-The CI workflow:
+## ESLint profiles
 
-- checks out full history
-- installs the pinned Bun version
-- installs dependencies with `bun install --frozen-lockfile`
-- runs `bunx @ankhorage/ankh doctor validate .`
-- conditionally runs build, lint, format check, Knip, tests, and typecheck when scripts exist
-- conditionally runs `changeset:status` for pull requests when the script exists
+`createConfig()` defaults to `profile: 'auto'`.
 
-The release workflow:
+Automatic detection reads the consuming repository's `package.json` and delegates project trait detection to `@ankhorage/utility/project`. Dependency signals are considered across `dependencies`, `devDependencies`, and `peerDependencies`.
 
-- checks out full history
-- configures Bun and Node for npm publishing
-- installs dependencies with the frozen lockfile
-- conditionally builds
-- runs the Changesets release PR/publish flow
-- protects release execution with a concurrency group
-- skips cleanly when no Changesets configuration exists
-
-## Managed VS Code configuration
-
-`vscode` owns exactly:
+Profile precedence is:
 
 ```text
-.vscode/settings.json
-.vscode/extensions.json
+React Native / Expo
+        ↓
+react-native
+        ↓ includes
+react
+        ↓ includes
+base
 ```
 
-The shared settings use the workspace TypeScript SDK, enable the workspace-SDK prompt, configure intentional ESLint save actions, and enforce basic whitespace/newline consistency.
-
-The extension recommendations are limited to the standard Ankhorage workflow:
-
-- Bun
-- ESLint
-- Prettier
-- YAML
-- GitHub Actions
-
-`launch.json` is intentionally not managed globally. Libraries, CLIs, Expo packages, services, and integration repositories require different debug configurations.
+A React or Next.js project selects `react`. A React Native or Expo project selects `react-native`. Everything else selects `base`.
 
-## ESLint
-
-Create `eslint.config.mjs`:
+An unusual repository can opt out of automatic selection:
 
 ```js
 import { createConfig } from '@ankhorage/devtools/eslint';
 
 export default createConfig({
-  files: ['src/**/*.{ts,tsx}'],
+  files: ['src/**/*.ts'],
+  profile: 'base',
   project: ['./tsconfig.json'],
   tsconfigRootDir: import.meta.dirname,
 });
 ```
 
-## Prettier
+The base profile enforces the shared TypeScript policy plus:
+
+- maximum 50 effective lines per function
+- maximum 300 effective lines per file
+- modified cyclomatic complexity maximum 15
+- security review for dynamic object access
+- rejection of non-literal `require()` calls
+
+The React profile adds React and React Hooks correctness rules. The React Native profile composes the React profile and adds the selected React Native style rules.
+
+### Managed ESLint setup and local overrides
 
-ES modules:
+`ankh devtools eslint sync` centrally owns `eslint.config.mjs` and creates `eslint.local.config.mjs` once.
+
+The canonical wrapper uses automatic profile detection and appends repository-owned flat-config entries:
 
 ```js
-export { default } from '@ankhorage/devtools/prettier';
+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,
+];
 ```
 
-CommonJS:
+Use `eslint.local.config.mjs` for narrow repository-specific flat-config overrides, including temporary file-specific migration overrides. On first synchronization, an existing non-canonical `eslint.config.mjs` is preserved as the initial local config before the canonical wrapper is installed. Synchronization never overwrites that local file afterward.
 
-```js
-module.exports = require('@ankhorage/devtools/prettier');
+## Prettier
+
+`ankh devtools prettier sync` owns `.prettierrc.js` and emits the correct ESM or CommonJS delegate based on the repository's `package.json` module type.
+
+The consumer delegates formatting policy to:
+
+```text
+@ankhorage/devtools/prettier
 ```
 
 ## Knip
 
+`ankh devtools knip sync` bootstraps `knip.config.ts` with:
+
 ```ts
 import { createKnipConfig } from '@ankhorage/devtools/knip';
 
 export default createKnipConfig();
 ```
 
-Monorepos can use `createKnipMonorepoConfig` and add narrow repository-specific entries, projects, ignores, binaries, dependencies, or workspace overrides.
+`knip.config.ts` is create-only after bootstrap so repositories can retain narrow local entries, projects, ignores, binaries, dependencies, or switch to `createKnipMonorepoConfig()` without synchronization overwriting those extensions.
+
+## Managed package contract
+
+`ankh devtools package sync` merge-updates `package.json` rather than replacing it.
+
+It owns:
+
+- the `@ankhorage/devtools` devDependency version range
+- `lint`
+- `lint:fix`
+- `format`
+- `format:check`
+- `knip`
+
+It also removes direct devDependencies for tools and ESLint plugins already provided by `@ankhorage/devtools`. Unrelated scripts, dependencies, metadata, and repository-specific configuration remain unchanged.
+
+## Managed GitHub Actions workflows
+
+`workflows` owns exactly:
+
+```text
+.github/workflows/ci.yml
+.github/workflows/release.yml
+```
+
+The CI workflow installs the pinned Bun version with the frozen lockfile, builds before repository-provider validation, runs `bunx @ankhorage/ankh doctor validate .`, and conditionally runs lint, formatting, Knip, tests, typecheck, and Changesets checks.
+
+## Managed VS Code configuration
+
+`vscode` owns exactly:
+
+```text
+.vscode/settings.json
+.vscode/extensions.json
+```
+
+Unknown workflow and VS Code files are never deleted.
 
 ## Adding another managed concern
 
@@ -243,7 +290,7 @@ A new concern should:
 
 1. live in its own sibling directory under `src/tools`
 2. define only the files and behavior it owns
-3. expose deterministic status and synchronization through the shared managed-file engine
+3. expose deterministic status and synchronization
 4. add provider commands under `ankh devtools`
-5. include source-tree, built-package, dry-run, status, and idempotence coverage
-6. document overwrite and exit-code behavior
+5. include dry-run, status, and idempotence coverage
+6. document its central ownership and repository-owned extension points

package/dist/cli/commands.d.ts

@@ -1,7 +1,7 @@
 export type DevtoolsToolName = 'format' | 'knip' | 'lint';
-type DevtoolsManagedScope = 'all' | 'vscode' | 'workflows';
+type DevtoolsManagedScope = 'all' | 'eslint' | 'knip' | 'package' | 'prettier' | 'vscode' | 'workflows';
 type DevtoolsManagedOperation = 'status' | 'sync';
-type DevtoolsCapability = 'devtools.format' | 'devtools.knip' | 'devtools.lint' | 'devtools.status' | 'devtools.sync' | 'devtools.vscode.status' | 'devtools.vscode.sync' | 'devtools.workflows.status' | 'devtools.workflows.sync';
+type DevtoolsCapability = 'devtools.format' | 'devtools.knip' | 'devtools.lint' | 'devtools.status' | 'devtools.sync' | 'devtools.eslint.status' | 'devtools.eslint.sync' | 'devtools.knip.status' | 'devtools.knip.sync' | 'devtools.package.status' | 'devtools.package.sync' | 'devtools.prettier.status' | 'devtools.prettier.sync' | 'devtools.vscode.status' | 'devtools.vscode.sync' | 'devtools.workflows.status' | 'devtools.workflows.sync';
 interface DevtoolsCommandBase {
     readonly path: readonly [string, ...string[]];
     readonly capability: DevtoolsCapability;

package/dist/cli/commands.js

@@ -1,79 +1,21 @@
 const DEVTOOLS_COMMANDS = [
-    {
-        kind: 'external',
-        toolName: 'lint',
-        path: ['lint'],
-        capability: 'devtools.lint',
-        summary: 'Run the shared ESLint toolchain.',
-        packageName: 'eslint',
-        binName: 'eslint',
-    },
-    {
-        kind: 'external',
-        toolName: 'format',
-        path: ['format'],
-        capability: 'devtools.format',
-        summary: 'Run the shared Prettier toolchain.',
-        packageName: 'prettier',
-        binName: 'prettier',
-    },
-    {
-        kind: 'external',
-        toolName: 'knip',
-        path: ['knip'],
-        capability: 'devtools.knip',
-        summary: 'Run the shared Knip toolchain.',
-        packageName: 'knip',
-        binName: 'knip',
-    },
-    {
-        kind: 'repository',
-        path: ['sync'],
-        capability: 'devtools.sync',
-        summary: 'Synchronize all centrally managed repository files.',
-        scope: 'all',
-        operation: 'sync',
-    },
-    {
-        kind: 'repository',
-        path: ['status'],
-        capability: 'devtools.status',
-        summary: 'Report drift for all centrally managed repository files.',
-        scope: 'all',
-        operation: 'status',
-    },
-    {
-        kind: 'repository',
-        path: ['workflows', 'sync'],
-        capability: 'devtools.workflows.sync',
-        summary: 'Synchronize the canonical GitHub Actions workflows.',
-        scope: 'workflows',
-        operation: 'sync',
-    },
-    {
-        kind: 'repository',
-        path: ['workflows', 'status'],
-        capability: 'devtools.workflows.status',
-        summary: 'Report drift for the canonical GitHub Actions workflows.',
-        scope: 'workflows',
-        operation: 'status',
-    },
-    {
-        kind: 'repository',
-        path: ['vscode', 'sync'],
-        capability: 'devtools.vscode.sync',
-        summary: 'Synchronize the canonical VS Code workspace configuration.',
-        scope: 'vscode',
-        operation: 'sync',
-    },
-    {
-        kind: 'repository',
-        path: ['vscode', 'status'],
-        capability: 'devtools.vscode.status',
-        summary: 'Report drift for the canonical VS Code workspace configuration.',
-        scope: 'vscode',
-        operation: 'status',
-    },
+    externalCommand('lint', 'devtools.lint', 'Run the shared ESLint toolchain.', 'eslint'),
+    externalCommand('format', 'devtools.format', 'Run the shared Prettier toolchain.', 'prettier'),
+    externalCommand('knip', 'devtools.knip', 'Run the shared Knip toolchain.', 'knip'),
+    repositoryCommand(['sync'], 'devtools.sync', 'Synchronize all managed repository setup.', 'all', 'sync'),
+    repositoryCommand(['status'], 'devtools.status', 'Report drift for all managed repository setup.', 'all', 'status'),
+    repositoryCommand(['eslint', 'sync'], 'devtools.eslint.sync', 'Synchronize the shared ESLint setup.', 'eslint', 'sync'),
+    repositoryCommand(['eslint', 'status'], 'devtools.eslint.status', 'Report drift for the shared ESLint setup.', 'eslint', 'status'),
+    repositoryCommand(['prettier', 'sync'], 'devtools.prettier.sync', 'Synchronize the shared Prettier setup.', 'prettier', 'sync'),
+    repositoryCommand(['prettier', 'status'], 'devtools.prettier.status', 'Report drift for the shared Prettier setup.', 'prettier', 'status'),
+    repositoryCommand(['knip', 'sync'], 'devtools.knip.sync', 'Synchronize the shared Knip setup.', 'knip', 'sync'),
+    repositoryCommand(['knip', 'status'], 'devtools.knip.status', 'Report drift for the shared Knip setup.', 'knip', 'status'),
+    repositoryCommand(['package', 'sync'], 'devtools.package.sync', 'Synchronize the shared package.json contract.', 'package', 'sync'),
+    repositoryCommand(['package', 'status'], 'devtools.package.status', 'Report drift for the shared package.json contract.', 'package', 'status'),
+    repositoryCommand(['workflows', 'sync'], 'devtools.workflows.sync', 'Synchronize the canonical GitHub Actions workflows.', 'workflows', 'sync'),
+    repositoryCommand(['workflows', 'status'], 'devtools.workflows.status', 'Report drift for the canonical GitHub Actions workflows.', 'workflows', 'status'),
+    repositoryCommand(['vscode', 'sync'], 'devtools.vscode.sync', 'Synchronize the canonical VS Code workspace configuration.', 'vscode', 'sync'),
+    repositoryCommand(['vscode', 'status'], 'devtools.vscode.status', 'Report drift for the canonical VS Code workspace configuration.', 'vscode', 'status'),
 ];
 export function getDevtoolsCommands() {
     return DEVTOOLS_COMMANDS;
@@ -90,3 +32,17 @@ export function getDevtoolsToolCommand(toolName) {
     }
     throw new Error(`Unknown devtools tool command: ${toolName}`);
 }
+function externalCommand(toolName, capability, summary, packageName) {
+    return {
+        kind: 'external',
+        toolName,
+        path: [toolName],
+        capability,
+        summary,
+        packageName,
+        binName: packageName,
+    };
+}
+function repositoryCommand(path, capability, summary, scope, operation) {
+    return { kind: 'repository', path, capability, summary, scope, operation };
+}

package/dist/cli/index.d.ts

@@ -2,10 +2,10 @@ declare const provider: {
     id: string;
     category: string;
     version: string;
-    capabilities: ("devtools.format" | "devtools.knip" | "devtools.lint" | "devtools.status" | "devtools.sync" | "devtools.vscode.status" | "devtools.vscode.sync" | "devtools.workflows.status" | "devtools.workflows.sync")[];
+    capabilities: ("devtools.format" | "devtools.knip" | "devtools.lint" | "devtools.status" | "devtools.sync" | "devtools.eslint.status" | "devtools.eslint.sync" | "devtools.knip.status" | "devtools.knip.sync" | "devtools.package.status" | "devtools.package.sync" | "devtools.prettier.status" | "devtools.prettier.sync" | "devtools.vscode.status" | "devtools.vscode.sync" | "devtools.workflows.status" | "devtools.workflows.sync")[];
     commands: {
         path: [string, ...string[]];
-        capability: "devtools.format" | "devtools.knip" | "devtools.lint" | "devtools.status" | "devtools.sync" | "devtools.vscode.status" | "devtools.vscode.sync" | "devtools.workflows.status" | "devtools.workflows.sync";
+        capability: "devtools.format" | "devtools.knip" | "devtools.lint" | "devtools.status" | "devtools.sync" | "devtools.eslint.status" | "devtools.eslint.sync" | "devtools.knip.status" | "devtools.knip.sync" | "devtools.package.status" | "devtools.package.sync" | "devtools.prettier.status" | "devtools.prettier.sync" | "devtools.vscode.status" | "devtools.vscode.sync" | "devtools.workflows.status" | "devtools.workflows.sync";
         summary: string;
     }[];
     handlers: {

package/dist/cli/index.js

@@ -1,3 +1,22 @@
+/***
+ * Run and synchronize the shared development toolchain through the Ankh CLI.
+ *
+ * `ankh devtools lint`, `ankh devtools format`, and `ankh devtools knip` execute the bundled
+ * ESLint, Prettier, and Knip versions. Repository synchronization is available through
+ * `ankh devtools sync` and `ankh devtools status`, with focused `eslint`, `prettier`, `knip`,
+ * `package`, `workflows`, and `vscode` sync/status subcommands.
+ *
+ * Sync commands accept an optional target directory and `--dry-run`. Aggregate sync is
+ * deterministic and idempotent: canonical managed files are created or updated, create-only
+ * local extension files remain repository-owned, and package metadata is merge-updated without
+ * replacing unrelated fields.
+ *
+ * Fresh repositories can bootstrap the standard setup with `ankh devtools sync .` after adding
+ * `@ankhorage/devtools`. Existing ESLint configuration is preserved during first migration as a
+ * local extension before the canonical auto-detecting wrapper is installed.
+ *
+ * @readme
+ */
 import { readFileSync } from 'node:fs';
 import { getDevtoolsCommands } from './commands.js';
 import { runProviderCommand } from './runProviderCommand.js';

package/dist/cli/runRepositoryCommand.js

@@ -1,30 +1,18 @@
+import { eslintManagedFiles } from '../tools/eslint/managed.js';
+import { knipManagedFiles } from '../tools/knip/managed.js';
+import { inspectPackageManifest, readCurrentDevtoolsVersion, syncPackageManifest, } from '../tools/package/index.js';
+import { prettierManagedFiles } from '../tools/prettier/managed.js';
 import { inspectManagedFiles, resolveManagedTargetDirectory, syncManagedFiles, } from '../tools/shared/managedFiles.js';
 import { vscodeManagedFiles } from '../tools/vscode/index.js';
 import { workflowManagedFiles } from '../tools/workflows/index.js';
 export async function runRepositoryCommand(command, argv, context) {
-    let parsedArguments;
     try {
-        parsedArguments = parseRepositoryArguments(argv, command.operation === 'sync');
-    }
-    catch (error) {
-        context.writeStderr(`${getErrorMessage(error)}\n`);
-        return { exitCode: 1 };
-    }
-    try {
-        const targetDirectory = await resolveManagedTargetDirectory(context.cwd, parsedArguments.targetPath);
-        const definitions = getManagedFiles(command.scope);
-        if (command.operation === 'status') {
-            const statuses = await inspectManagedFiles(targetDirectory, definitions);
-            writeStatusOutput(statuses, context);
-            return {
-                exitCode: statuses.some((status) => status.state !== 'current') ? 1 : 0,
-            };
-        }
-        const results = await syncManagedFiles(targetDirectory, definitions, {
-            dryRun: parsedArguments.dryRun,
-        });
-        writeSyncOutput(results, context);
-        return { exitCode: 0 };
+        const parsed = parseRepositoryArguments(argv, command.operation === 'sync');
+        const targetDirectory = await resolveManagedTargetDirectory(context.cwd, parsed.targetPath);
+        const devtoolsVersion = readCurrentDevtoolsVersion();
+        return command.operation === 'status'
+            ? await runStatus(command.scope, targetDirectory, devtoolsVersion, context)
+            : await runSync(command.scope, targetDirectory, devtoolsVersion, parsed.dryRun, context);
     }
     catch (error) {
         context.writeStderr(`${getErrorMessage(error)}\n`);
@@ -52,14 +40,39 @@ export function parseRepositoryArguments(argv, allowDryRun) {
     }
     return { dryRun, targetPath };
 }
+async function runStatus(scope, targetDirectory, devtoolsVersion, context) {
+    const statuses = [];
+    if (scope === 'all' || scope === 'package') {
+        statuses.push(await inspectPackageManifest(targetDirectory, devtoolsVersion));
+    }
+    statuses.push(...(await inspectManagedFiles(targetDirectory, getManagedFiles(scope))));
+    writeStatusOutput(statuses, context);
+    return { exitCode: statuses.some((status) => status.state !== 'current') ? 1 : 0 };
+}
+async function runSync(scope, targetDirectory, devtoolsVersion, dryRun, context) {
+    const results = [];
+    if (scope === 'all' || scope === 'package') {
+        results.push(await syncPackageManifest(targetDirectory, devtoolsVersion, { dryRun }));
+    }
+    results.push(...(await syncManagedFiles(targetDirectory, getManagedFiles(scope), { dryRun })));
+    writeSyncOutput(results, context);
+    return { exitCode: 0 };
+}
 function getManagedFiles(scope) {
-    if (scope === 'workflows') {
-        return workflowManagedFiles;
+    const definitionsByScope = {
+        eslint: eslintManagedFiles,
+        knip: knipManagedFiles,
+        prettier: prettierManagedFiles,
+        vscode: vscodeManagedFiles,
+        workflows: workflowManagedFiles,
+    };
+    if (scope === 'all') {
+        return Object.values(definitionsByScope).flat();
     }
-    if (scope === 'vscode') {
-        return vscodeManagedFiles;
+    if (scope === 'package') {
+        return [];
     }
-    return [...workflowManagedFiles, ...vscodeManagedFiles];
+    return definitionsByScope[scope];
 }
 function writeStatusOutput(statuses, context) {
     for (const status of statuses) {

package/dist/internal/readmeDocs.js

@@ -4,11 +4,21 @@ const REQUIRED_README_SNIPPETS = [
     'ankh devtools knip',
     'ankh devtools sync',
     'ankh devtools status',
+    'ankh devtools eslint sync',
+    'ankh devtools prettier sync',
+    'ankh devtools knip sync',
+    'ankh devtools package sync',
     'ankh devtools workflows sync',
     'ankh devtools vscode sync',
+    'devtools.eslint.sync',
+    'devtools.prettier.sync',
+    'devtools.knip.sync',
+    'devtools.package.sync',
     'devtools.workflows.sync',
     'devtools.vscode.sync',
     '--dry-run',
+    "profile: 'auto'",
+    '@ankhorage/utility/project',
 ];
 export function getReadmeDocumentationErrors(readmeContents) {
     return REQUIRED_README_SNIPPETS.flatMap((snippet) => readmeContents.includes(snippet)

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

@@ -6,4 +6,4 @@ export declare const defaultRestrictedImports: readonly [{
     readonly message: "Forbidden in Ankhorage packages. Use '@ankhorage/react-native-reanimated-dnd-web' directly.";
 }];
 export declare function createConfig(options: DevtoolsConfigOptions): ReturnType<typeof tseslint.config>;
-export type { DevtoolsConfigOptions, FlatConfigItem } from './types.js';
+export type { DevtoolsConfigOptions, DevtoolsEslintProfile, FlatConfigItem, ResolvedDevtoolsEslintProfile, RestrictedImport, } from './types.js';