declapract-typescript-ehmpathy 0.49.9 → 0.49.11

package/dist/.test/assets/expo-migration/declarations/practices/typescript-any/bad-practices/relative-imports/src/<star><star>/<star>.ts.declapract.ts

@@ -0,0 +1,97 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import { isDeferredToDeprecatedDirMove } from '../../../../../../utils/isDeferredToDeprecatedDirMove';
+
+/**
+ * .what = detects relative imports that should use @src alias
+ * .why = relative paths are fragile and break when files move
+ */
+
+// matches relative imports that go up directories (../)
+const RELATIVE_IMPORT_PATTERN = /from\s+['"](\.\.\/)+(.*?)['"]/g;
+
+const isInPracticesDir = (relativeFilePath: string | undefined): boolean =>
+  relativeFilePath?.includes('src/practices/') ?? false;
+
+const isDeclapractFile = (relativeFilePath: string | undefined): boolean =>
+  relativeFilePath?.endsWith('.declapract.ts') ?? false;
+
+/**
+ * skip files in src/practices/ because they are templates defining what target
+ * codebases should look like - not actual config files to be fixed. however,
+ * .declapract.ts files contain check/fix logic (not template content) so they
+ * should still be processed normally by other practices.
+ */
+const shouldSkip = (relativeFilePath: string | undefined): boolean =>
+  isInPracticesDir(relativeFilePath) && !isDeclapractFile(relativeFilePath);
+
+export const check: FileCheckFunction = (contents, { relativeFilePath }) => {
+  if (!contents) throw new Error('does not match bad practice');
+
+  // skip if file is not in src/
+  if (!relativeFilePath?.startsWith('src/')) {
+    throw new Error('does not match bad practice');
+  }
+
+  // skip practice template files
+  if (shouldSkip(relativeFilePath)) {
+    throw new Error('does not match bad practice');
+  }
+
+  // defer a file still under a deprecated dir to its peer dir-move: the move
+  // relocates it this pass, then this rewrite fires at the new path next pass.
+  // the two never touch one file in one apply, so no relocate+rewrite ENOENT.
+  if (isDeferredToDeprecatedDirMove({ relativeFilePath }))
+    throw new Error('deferred to peer dir-move this pass');
+
+  // check for relative imports that go up directories (../)
+  const matches = contents.match(RELATIVE_IMPORT_PATTERN);
+  if (matches && matches.length > 0) {
+    return; // matches bad practice
+  }
+
+  throw new Error('does not match bad practice');
+};
+
+export const fix: FileFixFunction = (contents, { relativeFilePath }) => {
+  if (!contents) return {};
+  if (!relativeFilePath?.startsWith('src/')) return {};
+  if (shouldSkip(relativeFilePath)) return {};
+
+  // defer a file still under a deprecated dir to its peer dir-move (see check)
+  if (isDeferredToDeprecatedDirMove({ relativeFilePath })) return {};
+
+  // calculate the path parts of the current file
+  const pathParts = relativeFilePath.split('/');
+  const srcIndex = pathParts.indexOf('src');
+
+  // get the directories between src/ and the current file
+  const currentDirParts = pathParts.slice(srcIndex + 1, -1);
+
+  // replace relative imports with @src imports (only if they stay within src/)
+  const fixed = contents.replace(
+    /from\s+['"]((\.\.\/)+)(.*?)['"]/g,
+    (match, dots, _, importPath) => {
+      // count how many ../ we have
+      const upCount = (dots.match(/\.\.\//g) || []).length;
+
+      // if going up more levels than we have directories within src/, it goes OUTSIDE src
+      // leave these imports unchanged (e.g., ../../package.json from src/utils/index.ts)
+      if (upCount > currentDirParts.length) {
+        return match;
+      }
+
+      // if going up exactly as many levels as we have directories, target is at src root
+      if (upCount === currentDirParts.length) {
+        return `from '@src/${importPath}'`;
+      }
+
+      // otherwise, calculate the remaining path after going up
+      const remainingParts = currentDirParts.slice(0, -upCount);
+      const targetPath = [...remainingParts, importPath].join('/');
+      return `from '@src/${targetPath}'`;
+    },
+  );
+
+  return { contents: fixed };
+};

package/dist/.test/assets/expo-migration/declarations/practices/typescript-any/best-practice/.declapract.readme.md

@@ -0,0 +1,17 @@
+this bundle defines the runtime-agnostic half of the typescript triad: the shared
+typecheck that every runtime runs, regardless of how it builds or bundles.
+
+namely:
+- the `test:types` command — `tsc -p ./tsconfig.json --noEmit`
+  - typechecks without a build, so it runs the same on node and expo
+  - the runtime halves (`typescript-node`, `typescript-expo`) ship the tsconfig it points at
+- the `typescript` dev dependency, pinned to a shared floor
+
+why a runtime-agnostic half:
+- the typecheck is identical across runtimes; only the build/bundle differs
+- so the shared command + dep live here, and each runtime half declares only its own
+  tsconfig + build (tsc-alias for node, metro/expo for expo)
+
+see the runtime halves for the build-specific config:
+- `typescript-node` — node16 tsconfig + `tsc` + `tsc-alias` post-compilation build
+- `typescript-expo` — `expo/tsconfig.base` + `expo export`, bundled by metro (no tsc build)

package/dist/.test/assets/expo-migration/declarations/practices/typescript-any/best-practice/package.json

@@ -0,0 +1,8 @@
+{
+  "devDependencies": {
+    "typescript": "@declapract{check.minVersion('5.4.5')}"
+  },
+  "scripts": {
+    "test:types": "tsc -p ./tsconfig.json --noEmit"
+  }
+}

package/dist/.test/assets/expo-migration/declarations/practices/typescript-any/best-practice/package.json.declapract.ts

@@ -0,0 +1,11 @@
+import { FileCheckType } from 'declapract';
+
+/**
+ * .what = the runtime-agnostic half of the typescript triad: the `typescript` dep
+ *         + the `tsc --noEmit` typecheck command
+ * .why  = the typecheck emits no output, so it is bound to no bundler and runs on any
+ *         runtime. the tsconfig.json it points at is supplied by the runtime half
+ *         (typescript-node or typescript-expo), so this practice pairs with exactly
+ *         one of them per usecase.
+ */
+export const check = FileCheckType.CONTAINS;

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/package.json

@@ -0,0 +1,6 @@
+{
+  "scripts": {
+    "build": "npm run build:web",
+    "build:web": "npx expo export --platform web"
+  }
+}

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/package.json.declapract.integration.test.ts

@@ -0,0 +1,30 @@
+import { FileCheckType } from 'declapract';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { check } from './package.json.declapract';
+
+/**
+ * .why integration = the build-command assertions read the shipped `package.json` template
+ *   from disk via readFileSync — a filesystem boundary. per rule.forbid.unit.remote-boundaries
+ *   a `.test.ts` (unit) may not cross an fs boundary, so this guard (which exists to catch
+ *   DRIFT in the real template's build commands) lives at the integration grain, where a real
+ *   file read is permitted. an inline copy would test a hardcoded string, not the template,
+ *   so it could not catch the drift this guards.
+ */
+describe('typescript-expo package.json', () => {
+  it('declares a CONTAINS check (a repo may add its own build variants)', () => {
+    expect(check).toEqual(FileCheckType.CONTAINS);
+  });
+
+  it('the emitted build command uses metro/EAS (expo export), not tsc', () => {
+    const template = JSON.parse(
+      readFileSync(path.join(__dirname, 'package.json'), 'utf-8'),
+    );
+    // `build` aliases build:web so the shared cicd `npm run build` works on expo
+    expect(template.scripts.build).toEqual('npm run build:web');
+    // the web build is expo export, NOT a tsc build (an expo app never builds with tsc)
+    expect(template.scripts['build:web']).toContain('expo export --platform web');
+    expect(template.scripts.build).not.toContain('tsc');
+  });
+});

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/package.json.declapract.ts

@@ -0,0 +1,12 @@
+import { FileCheckType } from 'declapract';
+
+/**
+ * .what = the expo half of the typescript triad: the `build` command that metro/EAS
+ *         use instead of tsc.
+ * .why  = an expo app never builds with tsc — metro bundles the native build and
+ *         `npx expo export --platform web` produces the web `dist/`. `build` aliases
+ *         `build:web` so the shared cicd-common `.test.yml` (which runs `npm run build`)
+ *         works on an expo repo, and `.deploy-expo.yml` (which runs `npm run build:web`)
+ *         works too. CONTAINS, so a repo may add its own build variants around these.
+ */
+export const check = FileCheckType.CONTAINS;

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@src/*": ["src/*"],
+      "@assets/*": ["assets/*"]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx"
+  ]
+}

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/tsconfig.json.declapract.integration.test.ts

@@ -0,0 +1,32 @@
+import { FileCheckType } from 'declapract';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { check } from './tsconfig.json.declapract';
+
+/**
+ * .why integration = the template-content assertions read the shipped `tsconfig.json`
+ *   template from disk via readFileSync — a filesystem boundary. per
+ *   rule.forbid.unit.remote-boundaries a `.test.ts` (unit) may not cross an fs boundary,
+ *   so this guard (which exists to catch DRIFT in the real template) lives at the
+ *   integration grain, where a real file read is permitted. an inline copy would test a
+ *   hardcoded string, not the template, so it could not catch the drift this guards.
+ */
+describe('typescript-expo tsconfig.json', () => {
+  it('declares a CONTAINS check (a consumer may customize around the expo base)', () => {
+    expect(check).toEqual(FileCheckType.CONTAINS);
+  });
+
+  it('the emitted template is expo-shaped, not node', () => {
+    const template = JSON.parse(
+      readFileSync(path.join(__dirname, 'tsconfig.json'), 'utf-8'),
+    );
+    // extends the expo base (jsx + react-native resolution), NOT @tsconfig/node20
+    expect(template.extends).toEqual('expo/tsconfig.base');
+    // the core path aliases a consumer relies on
+    expect(template.compilerOptions.paths['@src/*']).toEqual(['src/*']);
+    expect(template.compilerOptions.paths['@assets/*']).toEqual(['assets/*']);
+    // tsx is included (a react-native app has jsx), unlike the node tsconfig
+    expect(template.include).toContain('**/*.tsx');
+  });
+});

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/tsconfig.json.declapract.ts

@@ -0,0 +1,12 @@
+import { FileCheckType } from 'declapract';
+
+/**
+ * .what = the expo tsconfig: extends `expo/tsconfig.base` (jsx, react-native module
+ *         resolution) instead of the node16 `@tsconfig/node20` base.
+ * .why  = CONTAINS, not EQUALS, so an app that has already customized its expo tsconfig
+ *         (extra paths, an app-specific include) is NOT clobbered — the check only asserts
+ *         the expo base + core `@src`/`@assets` paths are present. a greenfield expo repo
+ *         gets this emitted by `declapract fix`; a repo like app-protools-native (already
+ *         `extends: expo/tsconfig.base`) already satisfies it.
+ */
+export const check = FileCheckType.CONTAINS;

package/dist/.test/assets/expo-migration/declarations/useCases.yml

@@ -0,0 +1,21 @@
+# the migration slice of the app-react-native-expo usecase
+# .why = these are the practices that touch a file an already-built expo app repo already
+#        has, so they are the ones whose GRACEFUL migration (rename / union / forget /
+#        merge-not-clobber) must be proven against a real app-protools-native-shaped repo.
+#        config-only practices that merely DROP a net-new file (lint, format, husky, …) add
+#        no migration risk and are already covered by the tests-expo pipeline test; this
+#        fixture isolates the practices that MUTATE an extant repo's files.
+use-cases:
+  app-react-native-expo:
+    practices:
+      - git
+      - rhachet
+      - node
+      - pnpm
+      - directory-structure-src
+      - domain
+      - typescript-any
+      - typescript-expo
+      - tests-any
+      - tests-expo
+      - cicd-app-react-native-expo

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/.github/workflows/.deploy-expo.yml

@@ -0,0 +1,30 @@
+name: .deploy-expo
+
+on:
+  workflow_call:
+    inputs:
+      stage:
+        type: string
+        required: true
+
+jobs:
+  deploy-os:
+    name: deploy
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: set node-version
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: ".nvmrc"
+
+      - name: cache node_modules
+        uses: actions/cache@v4
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-${{ hashFiles('package-lock.json') }}
+
+      - name: install
+        run: npm ci

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/.husky/check.lockfile.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# warn the human when the lockfile changed and deps may be stale
+if git diff --name-only HEAD@{1} HEAD | grep -q 'package-lock.json'; then
+  echo "🔒 package-lock.json changed — run npm install"
+fi

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/declapract.use.yml

@@ -0,0 +1,24 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/expo-migration/declarations
+# .why  = an already-built expo app repo (the app-protools-native shape) on npm + the
+#         deprecated src/logic/ + src/data/ layers, used to prove the whole migration slice
+#         applies gracefully — rename, not delete; union, not clobber; forget, not destroy.
+declarations: 'declarations/declapract.declare.yml'
+useCase: app-react-native-expo
+# .note = the apply evaluates the WHOLE usecase before any file-filter, so EVERY variable
+#         any file in ANY of the ten practices references must be defined here, or evaluation
+#         throws `Variable … was not defined`.
+variables:
+  projectName: app-protools-native
+  organizationName: ahbode
+  infrastructureNamespaceId: aaa000
+  awsAccountId:
+    prep: '111111111111'
+    prod: '222222222222'
+  app:
+    web:
+      domain:
+        prep: protools.prep.ahbode.dev
+        prod: protools.ahbode.dev
+      port:
+        hot: 3447
+        cold: 3449

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/jest.config.js

@@ -0,0 +1,8 @@
+// a stale JS jest config (jsdom) — the exact dual-source hazard the app-protools-native
+// audit names. the go-forward is jest.config.ts (the tests-expo best-practice template),
+// so the tests-any `javascript-config-files` bad-practice must DELETE this on `declapract
+// fix`; the shipped .ts config then stands as the single source.
+module.exports = {
+  testEnvironment: 'jsdom',
+  preset: 'jest-expo',
+};

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/package-lock.json

@@ -0,0 +1,7 @@
+{
+  "name": "app-protools-shaped",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "app-protools-shaped",
+  "version": "1.0.0",
+  "packageManager": "pnpm@10.32.1",
+  "scripts": {
+    "install:deps": "npm install",
+    "start": "expo start"
+  },
+  "overrides": {
+    "type-fns": "1.9.9"
+  },
+  "resolutions": {
+    "@commitlint/format": "19.9.9"
+  },
+  "jest": {
+    "preset": "jest-expo",
+    "testEnvironment": "jsdom"
+  },
+  "devDependencies": {
+    "expo": "54.0.0"
+  }
+}

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/pnpm-lock.yaml

@@ -0,0 +1,5 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/src/data/dao/daoCustomer.ts

@@ -0,0 +1,9 @@
+// a deprecated data-layer dao. the directory-structure-src migration must move this file
+// data/dao/ -> access/daos/ (the dao-specific rename, not the generic data/ -> access/).
+export interface Customer {
+  id: string;
+  name: string;
+}
+export const daoCustomer = {
+  findById: async (id: string): Promise<Customer> => ({ id, name: 'test' }),
+};

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/src/logic/customer/getCustomer.ts

@@ -0,0 +1,25 @@
+// a deprecated-layer operation that imports from the deprecated data-layer dao
+// via the @src alias (the go-forward import style the relative-imports practice
+// pushes repos toward). the directory-structure-src migration must move this file
+// logic/ -> domain.operations/ AND rewrite the import path data/dao -> access/daos.
+//
+// this file deliberately carries THREE distinct import SHAPES that all reference the
+// deprecated data/ layer, so the pipeline rewrite is proven to handle more than one
+// import per file (the r10 blocker-3 case): a plain value import, a type-only import,
+// and a barrel re-export. every one must land at access/daos, none may keep data/dao.
+import { daoCustomer } from '@src/data/dao/daoCustomer';
+import type { Customer } from '@src/data/dao/daoCustomer';
+export { daoCustomer as daoCustomerReExport } from '@src/data/dao/daoCustomer';
+
+// a `../` RELATIVE import to a peer in the same deprecated layer. relative-imports must
+// rewrite it to the @src alias — but only AFTER the dir-move relocates this file out of
+// logic/. on pass 1 this file still sits under the deprecated logic/ dir, so relative-imports
+// DEFERS (its isDeferredToDeprecatedDirMove guard) while old-logic-dir relocates the file; on
+// pass 2 the file sits at domain.operations/ and relative-imports fires and converts
+// ../shared/formatCustomer -> @src/domain.operations/shared/formatCustomer. proves the
+// branch-new deferred-dir guard end-to-end (the r1 relative-imports blocker).
+import { formatCustomer } from '../shared/formatCustomer';
+
+export const getCustomer = async (input: { id: string }): Promise<Customer> => {
+  return formatCustomer(await daoCustomer.findById(input.id));
+};

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/src/logic/shared/formatCustomer.ts

@@ -0,0 +1,8 @@
+// a peer util in the SAME deprecated layer (src/logic/shared/). getCustomer.ts imports
+// this via a `../shared/formatCustomer` RELATIVE path, so the migration must BOTH relocate
+// this file (logic/shared/ -> domain.operations/shared/) AND rewrite the relative import in
+// its importer to the @src alias — a two-pass settle the relative-imports deferred-dir guard
+// governs. it exists so the pipeline exercises relative-imports end-to-end.
+import type { Customer } from '@src/data/dao/daoCustomer';
+
+export const formatCustomer = (customer: Customer): Customer => customer;

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@src/*": ["src/*"],
+      "@assets/*": ["assets/*"],
+      "@app-custom/*": ["src/app-custom/*"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.tsx", ".expo/types/**/*.ts", "expo-env.d.ts"]
+}

package/dist/.test/assets/expo-toolchain/declarations/declapract.declare.yml

@@ -0,0 +1,4 @@
+# minimal declarations for the expo test-toolchain integration test
+declare:
+  practices: practices
+  use-cases: useCases.yml

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/javascript-config-files/.declapract.readme.md

@@ -0,0 +1 @@
+we've migrated to using `.ts` config files for jest config, rather than `.js`

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/javascript-config-files/jest.<star>.js.declapract.ts

@@ -0,0 +1,17 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.EXISTS;
+
+/**
+ * .what = deletes a stale `.js` jest config file
+ * .why  = the go-forward jest config is `.ts` (see .declapract.readme.md). a leftover
+ *         `.js` jest config (e.g. a jsdom `jest.config.js` or a `jest.unit.config.js`)
+ *         is redundant and fights the shipped `.ts` config — the dual-source hazard the
+ *         app-protools-native migration must reconcile. drop the redundant `.js`; the
+ *         best-practice supplies the canonical `.ts` config in the same pass.
+ * .note  = `{ contents: null }` removes the file. idempotent: once gone, the EXISTS
+ *          check no longer detects it, so a re-run is a no-op.
+ */
+export const fix: FileFixFunction = () => {
+  return { contents: null };
+};

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/mocks/.declapract.readme.md

@@ -0,0 +1,8 @@
+should not have any `__mock__` directories
+
+these are hard to track down and are too "magical" and affect _all_ tests (i.e., inter test dependency)
+
+just explicitly mocks manually in each test OR root level in setup env with:
+```ts
+jest.mock("...");
+```

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/mocks/<star><star>/__mock__/<star>.js

@@ -0,0 +1,3 @@
+/**
+ * bad practice: file exists
+ */

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/mocks/<star><star>/__mock__/<star>.ts

@@ -0,0 +1,3 @@
+/**
+ * bad practice: file exists
+ */

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.declapract.integration.test.ts

@@ -0,0 +1,63 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+/**
+ * .what = integration test for old-acceptance-dir-location bad practice
+ * .why = reproduces bug where files with non-ts extensions are silently dropped
+ */
+describe('old-acceptance-dir-location', () => {
+  given('[case1] accept.blackbox/ with various file types', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-old-acceptance-dir',
+      clone: './src/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir',
+      symlink: [{ at: 'src', to: 'src' }],
+    });
+
+    when('[t0] before fix', () => {
+      then('accept.blackbox/ contains files', async () => {
+        const rhachetFile = path.join(
+          tempDir,
+          'accept.blackbox/.test/assets/.rhachet/manifest.json',
+        );
+        const stats = await fs.stat(rhachetFile);
+        expect(stats.isFile()).toBe(true);
+      });
+    });
+
+    when('[t1] declapract fix is applied', () => {
+      useThen('fix is applied', async () => {
+        await executeApply({
+          config: path.join(tempDir, 'declapract.use.yml'),
+          practice: 'tests-any',
+        });
+      });
+
+      then('somefile.ts is moved to blackbox/', async () => {
+        const newPath = path.join(tempDir, 'blackbox/somefile.ts');
+        const stats = await fs.stat(newPath).catch(() => null);
+        expect(stats?.isFile()).toBe(true);
+      });
+
+      then('.rhachet/manifest.json is moved to blackbox/', async () => {
+        const newPath = path.join(
+          tempDir,
+          'blackbox/.test/assets/.rhachet/manifest.json',
+        );
+        const stats = await fs.stat(newPath).catch(() => null);
+        expect(stats?.isFile()).toBe(true);
+      });
+
+      then('.agent/config.yml is moved to blackbox/', async () => {
+        const newPath = path.join(
+          tempDir,
+          'blackbox/.test/assets/.agent/config.yml',
+        );
+        const stats = await fs.stat(newPath).catch(() => null);
+        expect(stats?.isFile()).toBe(true);
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.declapract.readme.md

@@ -0,0 +1,22 @@
+# old-acceptance-dir-location
+
+## .what
+
+detects test files located in `acceptance/` or `accept.blackbox/` directories and migrates them to `blackbox/`.
+
+## .why
+
+the term "blackbox" makes the testing philosophy explicit:
+- blackbox tests interact only through public contracts (APIs, CLIs, SDKs)
+- no access to internal implementation details
+- tests validate behavior from the caller's perspective
+
+the rename from `acceptance/` or `accept.blackbox/` to `blackbox/` clarifies this intent and simplifies the naming.
+
+## .fix
+
+moves all files from `acceptance/` or `accept.blackbox/` to `blackbox/` while preserving the directory structure.
+
+## .note
+
+the `.acceptance.test.ts` file extension is preserved — it communicates the test type while the directory name communicates the testing philosophy.

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/accept.blackbox/.test/assets/.agent/config.yml

@@ -0,0 +1 @@
+key: value

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/accept.blackbox/.test/assets/.rhachet/manifest.json

@@ -0,0 +1 @@
+{}

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/accept.blackbox/somefile.ts

@@ -0,0 +1 @@
+export const x = 1;

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/declapract.declare.yml

@@ -0,0 +1,4 @@
+declare:
+  examples: src/examples
+  practices: src/practices
+  use-cases: src/useCases.yml

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/declapract.use.yml

@@ -0,0 +1,5 @@
+declarations: './'
+useCase: typescript-project
+variables:
+  organizationName: 'test-org'
+  projectName: 'test-project'

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "test-project",
+  "version": "1.0.0"
+}

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/accept.blackbox/<star><star>/<star>.declapract.ts

@@ -0,0 +1,19 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.EXISTS; // if any files exist in accept.blackbox/, flag as bad practice
+
+/**
+ * .what = moves any file from accept.blackbox/ to blackbox/
+ * .why = ensures all files are moved, not just .ts files — prevents silent data loss for hidden paths
+ */
+export const fix: FileFixFunction = (contents, context) => {
+  // move from accept.blackbox/ to blackbox/
+  const newPath = context.relativeFilePath.replace(
+    /^accept\.blackbox\//,
+    'blackbox/',
+  );
+  return {
+    contents: contents ?? null,
+    relativeFilePath: newPath,
+  };
+};