agents-md-kit 0.0.0-stage → 0.1.0

package/presets/react-typescript/files/.claude/skills/react-principles/SKILL.md

@@ -0,0 +1,264 @@
+---
+name: react-principles
+description: Principles and practices for writing React: SOLID, DRY/KISS/YAGNI, Hooks, state, effects, TypeScript and testing. Use when creating, refactoring or reviewing React components, Hooks, props or frontend structure.
+---
+
+# React Principles
+
+Three parts: Part 1 structures components (SOLID), Part 2 keeps them simple (DRY, KISS, YAGNI), Part 3 covers everyday React practice. When Part 1 and Part 2 pull in different directions, choose the simpler solution that meets today's concrete requirements.
+
+## Part 1: SOLID Principles
+
+Use these principles to keep components small, composable and testable. When writing or reviewing React code, check each principle below. Apply them with judgment: a principle is a guide to better structure, not a reason to over-engineer (see Part 2, especially KISS and YAGNI).
+
+### 1. Single Responsibility Principle (SRP)
+
+**Rule:** A component or Hook has one reason to change.
+
+**Do**
+- Split components that fetch data, manage forms and render complex layouts into small UI components plus dedicated custom Hooks.
+- Put data fetching, subscriptions and form logic in Hooks (`useUser`, `useCheckoutForm`).
+- Keep presentational components free of side effects where possible.
+
+**Don't**
+- Build one component that fetches, validates, transforms and renders everything.
+
+```tsx
+// Bad: fetching + state + rendering in one component
+function UserProfile({ id }) {
+  const [user, setUser] = useState(null);
+  useEffect(() => { fetch(`/api/users/${id}`).then(r => r.json()).then(setUser); }, [id]);
+  return user ? <div>{/* 80 lines of layout */}</div> : <Spinner />;
+}
+
+// Good: logic in a Hook, rendering in a UI component
+function useUser(id: string) { /* fetching + state */ }
+function UserProfile({ id }: { id: string }) {
+  const { user, isLoading } = useUser(id);
+  return isLoading ? <Spinner /> : <UserCard user={user} />;
+}
+```
+
+**Smell check:** if you describe the component using "and" ("fetches users and renders the table and handles the form"), split it.
+
+### 2. Open/Closed Principle (OCP)
+
+**Rule:** Components are open for extension but closed for modification. Extend behavior from the outside instead of editing the component's source.
+
+**Do**
+- Accept `children`, render props, slots (`header`, `footer`) or `className`/`style` props.
+- Use composition (compound components) for variants with different content.
+
+**Don't**
+- Add a new boolean flag or `if/else` branch every time a new variation is needed (`isCompact`, `isSpecial`, `showFooterV2`).
+
+```tsx
+// Bad: grows a new flag per use case
+<Card showHeader showFooter isCompact withIcon />
+
+// Good: extend through composition
+<Card>
+  <Card.Header>Title</Card.Header>
+  <Card.Body>...</Card.Body>
+  <Card.Footer><Button>Save</Button></Card.Footer>
+</Card>
+```
+
+### 3. Liskov Substitution Principle (LSP)
+
+**Rule:** A specialized component must be usable anywhere its base component is, without breaking behavior.
+
+**Do**
+- When wrapping a native element, extend its props type and forward them (`React.ComponentPropsWithoutRef<'button'>`).
+- Forward `ref` (`forwardRef`, or the `ref` prop in React 19+) when the base element supports it.
+- Spread remaining props onto the underlying element.
+
+**Don't**
+- Swallow or rename standard props (`onClick`, `disabled`, `type`, `aria-*`).
+- Change the expected behavior of the base element (e.g. a "button" that ignores `disabled`).
+
+```tsx
+type PrimaryButtonProps = React.ComponentPropsWithoutRef<'button'> & {
+  tone?: 'default' | 'danger';
+};
+
+function PrimaryButton({ tone = 'default', className, ...rest }: PrimaryButtonProps) {
+  return <button className={cx('btn-primary', tone, className)} {...rest} />;
+}
+```
+
+### 4. Interface Segregation Principle (ISP)
+
+**Rule:** Components should not depend on props they do not use. Props are the component's interface; keep it minimal.
+
+**Do**
+- Pass only the specific values a component needs.
+- Define narrow prop types for each component.
+
+**Don't**
+- Pass whole objects (`user`, `order`, `config`) when only a few fields are used.
+
+```tsx
+// Bad: depends on a 20-field User type to show an image and a name
+<Avatar user={user} />
+
+// Good: depends only on what it renders
+<Avatar imageUrl={user.imageUrl} username={user.username} />
+```
+
+**Exception:** if a component genuinely represents the whole entity (e.g. `<UserCard user={user} />`), passing the object is fine. Keep that type as narrow as practical (`Pick<User, 'name' | 'imageUrl'>`).
+
+### 5. Dependency Inversion Principle (DIP)
+
+**Rule:** High-level UI components depend on abstractions, not on concrete low-level details such as a specific API client, `fetch`, `localStorage` or an analytics SDK.
+
+**Do**
+- Wrap external services in custom Hooks (`useTodos`, `useLocalPreference`) or Context providers.
+- Inject dependencies through Context or props so tests can swap in mocks.
+- Keep the Hook's returned shape independent of the underlying implementation.
+
+**Don't**
+- Call `fetch`, `axios`, `localStorage` or SDK clients directly inside presentational components.
+
+```tsx
+// Component depends on an abstraction (the Hook's contract)
+function TodoList() {
+  const { todos, isLoading } = useTodos();
+  ...
+}
+
+// Implementation can change (REST, GraphQL, mock) without touching TodoList
+function useTodos() { /* uses api client from context */ }
+```
+
+### SOLID Review Checklist
+
+Before finishing a React change, confirm:
+
+- [ ] Each component/Hook has one clear reason to change (SRP)
+- [ ] New variations are added via `children`/render props/styling props, not new flags (OCP)
+- [ ] Wrapper components accept and forward the base element's standard props (LSP)
+- [ ] Components receive only the props they use (ISP)
+- [ ] External services are behind Hooks or Context, and components are testable with mocks (DIP)
+
+## Part 2: DRY, KISS, YAGNI
+
+These rules keep React code simple and balanced. Use them alongside Part 1 (SOLID). When the two pull in different directions, prefer the simpler solution that meets today's concrete requirements.
+
+### DRY: Don't Repeat Yourself
+
+**Rule:** Extract repeated JSX into reusable components and duplicated stateful logic into custom Hooks.
+
+**Do**
+- Extract JSX that appears in several places into one component.
+- Move repeated `useState` + `useEffect` patterns into a custom Hook (`useDebounce`, `useToggle`, `useFetch`).
+- Share constants, types and validation rules from one place.
+
+**Don't**
+- Abstract after the first duplication. Wait until the same code appears about three times (the "rule of three") or the duplication is clearly the same concept.
+- Merge code that looks alike but changes for different reasons. A wrong abstraction costs more than duplication.
+
+```tsx
+// Duplicated logic in several components
+const [open, setOpen] = useState(false);
+const toggle = () => setOpen(o => !o);
+
+// Extracted once
+function useToggle(initial = false) {
+  const [on, setOn] = useState(initial);
+  const toggle = useCallback(() => setOn(o => !o), []);
+  return [on, toggle] as const;
+}
+```
+
+### KISS: Keep It Simple, Stupid
+
+**Rule:** Prefer the most straightforward solution that works.
+
+**Do**
+- Start with `useState`, `useReducer` and plain prop passing.
+- Lift state up before reaching for Context; use Context before reaching for a state library.
+- Add a state management library (Redux, Zustand, etc.) only when the app genuinely needs it: many distant components sharing complex state, or heavy cross-cutting updates.
+- Write code a new teammate can read top to bottom.
+
+**Don't**
+- Introduce global stores, custom abstractions or deep indirection for state that a single component or parent owns.
+- Use clever one-liners or patterns that hide intent.
+
+### YAGNI: You Aren't Gonna Need It
+
+**Rule:** Build only what is needed now.
+
+**Do**
+- Write the straightforward version first, then measure.
+- Add `useMemo`, `useCallback` and `React.memo` only after profiling (React DevTools Profiler) shows a real bottleneck, or when referential stability is required for correctness (e.g. a stable dependency for an effect or a memoized child).
+- Add props, config options and abstraction layers when a concrete use case exists.
+
+**Don't**
+- Wrap every function in `useCallback` or every value in `useMemo` by default.
+- Add "just in case" props, generic wrapper components or plugin systems for imagined future needs.
+
+### Quick Decision Guide
+
+| Situation | Choose |
+|---|---|
+| Same JSX/logic copied 3+ times for the same reason | Extract (DRY) |
+| Two snippets look similar but change for different reasons | Leave duplicated |
+| State used by one component or its parent | `useState` / prop passing (KISS) |
+| Slow render observed in the profiler | Add memoization (YAGNI satisfied) |
+| "We might need this later" | Don't build it yet |
+
+### DRY/KISS/YAGNI Review Checklist
+
+- [ ] Repeated JSX/logic extracted only where it is truly the same concept (DRY)
+- [ ] State handled with the simplest tool that fits (KISS)
+- [ ] No premature `useMemo`/`useCallback`/abstractions without a measured need (YAGNI)
+
+## Part 3: React Practices
+
+### Hooks
+- Call Hooks only at the top level of components and custom Hooks, never inside conditions, loops or nested functions. Custom Hooks start with `use`.
+- Keep the `react-hooks/exhaustive-deps` lint rule on. Fix dependency arrays instead of suppressing the warning.
+
+### State
+- Keep state as local as possible. Lift it up only when siblings need it.
+- Don't store derived data in state. Compute it during render.
+- Server data: use a data-fetching library (TanStack Query, SWR, framework loaders) instead of hand-rolled `useEffect` + `useState`. Always handle loading, error and empty states.
+- Use `useReducer` for related transitions. Replace piles of boolean flags with a status union (`'idle' | 'loading' | 'success' | 'error'`).
+- Never mutate state or props. Create new objects and arrays.
+- Large forms: use a form library (React Hook Form) and validate with the same schema as the backend where possible.
+
+### Effects
+- Effects synchronize with external systems (subscriptions, timers, DOM APIs). They are not for transforming data, handling events (use handlers) or resetting state on prop change (use `key`).
+- Always clean up subscriptions, timers, listeners and in-flight requests (`AbortController`). Effects must survive Strict Mode's double invocation.
+
+### Rendering and Keys
+- Render is pure: no side effects, no randomness, no mutation.
+- Stable, unique `key` for list items. Don't use the array index for lists that reorder or change.
+- Never define a component inside another component.
+- Code-split routes (`React.lazy` + `Suspense`), virtualize very long lists, and measure before memoizing (YAGNI).
+
+### TypeScript
+- Use `strict` mode. Type props explicitly, avoid `any`, and model variants with discriminated unions.
+- Wrapper components extend native props (`React.ComponentPropsWithoutRef<'button'>`).
+- Prefer `unknown` over `any` for untrusted data, then narrow it. Parse API responses with a schema (Zod) at the boundary.
+
+### Structure and Naming
+- Organize by feature and colocate the component, hooks, styles and tests. Components are PascalCase, Hooks are `useX`, and each file has one main component.
+- Use barrel files sparingly. They hurt tree-shaking and create import cycles.
+
+### Accessibility, SEO and Security
+- Follow `html-syntax-and-semantics`. Keep `eslint-plugin-jsx-a11y` enabled. Public pages use SSR/SSG per `seo-best-practices`.
+- Never render unsanitized HTML with `dangerouslySetInnerHTML`. Validate URLs placed in `href`/`src` (block `javascript:`). Anything in a client bundle is public (`VITE_*`, `NEXT_PUBLIC_*`), so never put secrets there. See `backend-security`.
+
+### Testing
+- Vitest or Jest with React Testing Library: query by role, label and text, and test behavior, not implementation details.
+- Mock the network with MSW. Test Hooks through components or `renderHook`. Add axe checks for accessibility.
+- Playwright for a few critical end-to-end flows.
+
+### React Practices Checklist
+- [ ] Hooks rules and exhaustive-deps satisfied; effects clean up
+- [ ] No derived state; server data handled by a data library with loading/error/empty states
+- [ ] Stable keys; no components defined inside components
+- [ ] Strict TypeScript, no `any`, narrow prop types
+- [ ] Tests assert user-visible behavior; a11y lint and axe pass

package/presets/react-typescript/files/.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false

package/presets/react-typescript/files/.husky/commit-msg

@@ -0,0 +1 @@
+npx --no -- commitlint --edit "$1"

package/presets/react-typescript/files/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/presets/react-typescript/files/.lintstagedrc.json

@@ -0,0 +1,4 @@
+{
+  "*.{js,jsx,mjs,cjs,ts,tsx}": ["eslint --fix", "prettier --write"],
+  "*.{json,md,css,scss,html,yml,yaml}": ["prettier --write"]
+}

package/presets/react-typescript/files/.prettierrc.json

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "printWidth": 100,
+  "arrowParens": "always"
+}

package/presets/react-typescript/files/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.0.0"
+}

package/presets/react-typescript/files/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+This file is generated by [release-please](https://github.com/googleapis/release-please) from Conventional Commits. Do not edit it by hand. See the `changelog-and-versioning` skill.

package/presets/react-typescript/files/commitlint.config.mjs

@@ -0,0 +1,12 @@
+// Enforces Conventional Commits. See the git-commit-and-workflow skill.
+export default {
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    // Subject line (header) at most 72 characters.
+    'header-max-length': [2, 'always', 72],
+    // Body lines: warn above 100 chars (URLs and stack traces can be long).
+    'body-max-line-length': [1, 'always', 100],
+    // Uncomment to restrict scopes to your project's modules:
+    // 'scope-enum': [2, 'always', ['auth', 'checkout', 'api', 'db', 'ui', 'deps', 'release']],
+  },
+};

package/presets/react-typescript/files/eslint.config.mjs

@@ -0,0 +1,55 @@
+// ESLint flat config for React + TypeScript.
+// Rules here back up the react-principles and html-syntax-and-semantics skills.
+import js from '@eslint/js';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+import react from 'eslint-plugin-react';
+import reactHooks from 'eslint-plugin-react-hooks';
+import jsxA11y from 'eslint-plugin-jsx-a11y';
+import prettier from 'eslint-config-prettier';
+
+export default [
+  { ignores: ['dist', 'build', 'coverage', '.next', 'node_modules', 'CHANGELOG.md'] },
+
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+
+  react.configs.flat.recommended,
+  react.configs.flat['jsx-runtime'],
+  jsxA11y.flatConfigs.recommended,
+
+  {
+    files: ['**/*.{js,jsx,mjs,cjs,ts,tsx}'],
+    languageOptions: {
+      globals: { ...globals.browser, ...globals.node },
+    },
+    settings: { react: { version: 'detect' } },
+    plugins: { 'react-hooks': reactHooks },
+    rules: {
+      // Hooks (react-principles, Part 3)
+      'react-hooks/rules-of-hooks': 'error',
+      'react-hooks/exhaustive-deps': 'warn',
+
+      // React
+      'react/jsx-key': 'error',
+      'react/no-danger': 'warn',
+      'react/self-closing-comp': 'warn',
+      'react/prop-types': 'off', // TypeScript types replace prop-types
+      'react/jsx-no-target-blank': 'error',
+
+      // TypeScript
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
+      ],
+
+      // General
+      eqeqeq: ['error', 'always'],
+      'no-console': ['warn', { allow: ['warn', 'error'] }],
+    },
+  },
+
+  // Must stay last: turns off rules that conflict with Prettier.
+  prettier,
+];

package/presets/react-typescript/files/release-please-config.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+  "release-type": "node",
+  "include-component-in-tag": false,
+  "bump-minor-pre-major": true,
+  "bump-patch-for-minor-pre-major": false,
+  "packages": {
+    ".": {
+      "changelog-path": "CHANGELOG.md"
+    }
+  },
+  "changelog-sections": [
+    { "type": "feat", "section": "Added" },
+    { "type": "fix", "section": "Fixed" },
+    { "type": "perf", "section": "Changed" },
+    { "type": "revert", "section": "Changed" },
+    { "type": "docs", "section": "Documentation", "hidden": true },
+    { "type": "style", "section": "Styles", "hidden": true },
+    { "type": "refactor", "section": "Refactoring", "hidden": true },
+    { "type": "test", "section": "Tests", "hidden": true },
+    { "type": "build", "section": "Build", "hidden": true },
+    { "type": "ci", "section": "CI", "hidden": true },
+    { "type": "chore", "section": "Chores", "hidden": true }
+  ]
+}

package/presets/react-typescript/fragments/agents-react-typescript-github.md

@@ -0,0 +1,7 @@
+### GitHub automation (react-typescript preset + github pack)
+
+| Tool | Config | Enforces |
+|---|---|---|
+| CI | `.github/workflows/ci.yml` | Lint, format check, typecheck, test, build, dependency audit |
+| release-please | `release-please-config.json`, `.release-please-manifest.json`, `.github/workflows/release-please.yml` | Version bumps, `CHANGELOG.md`, tags. Don't hand-edit `CHANGELOG.md` or version fields |
+| Dependabot | `.github/dependabot.yml` | Weekly npm and GitHub Actions updates with Conventional Commit messages |

package/presets/react-typescript/fragments/agents-react-typescript.md

@@ -0,0 +1,17 @@
+## React + TypeScript
+
+| Area | Skill | Load when |
+|---|---|---|
+| React | `react-principles` | Creating/refactoring components and Hooks, props, state, effects, abstractions, memoization |
+
+### Tooling (installed by the react-typescript preset; don't work around it)
+
+| Tool | Config | Enforces |
+|---|---|---|
+| commitlint + husky `commit-msg` | `commitlint.config.mjs`, `.husky/commit-msg` | Conventional Commit format on every commit |
+| lint-staged + husky `pre-commit` | `.lintstagedrc.json`, `.husky/pre-commit` | ESLint and Prettier on staged files |
+| ESLint | `eslint.config.mjs` | TypeScript, React, Hooks and jsx-a11y rules |
+| Prettier | `.prettierrc.json`, `.prettierignore` | Formatting |
+| EditorConfig | `.editorconfig` | Charset, line endings, indentation |
+
+Never bypass these (`--no-verify`, disabling rules to make a check pass). Fix the underlying issue. Setup and versions: `docs/agent-kit/react-typescript.md`.

package/presets/react-typescript/fragments/gitignore.txt

@@ -0,0 +1,22 @@
+# Dependencies
+node_modules/
+
+# Build output
+dist/
+build/
+coverage/
+.next/
+.vite/
+.turbo/
+
+# Environment and secrets (keep .env.example)
+.env
+.env.*
+!.env.example
+
+# Logs and OS/editor files
+*.log
+.DS_Store
+.idea/
+.vscode/*
+!.vscode/extensions.json

package/presets/react-typescript/fragments/prettierignore.txt

@@ -0,0 +1,17 @@
+node_modules
+dist
+build
+coverage
+.next
+package-lock.json
+pnpm-lock.yaml
+yarn.lock
+CHANGELOG.md
+.release-please-manifest.json
+# Files agent-kit owns and compares on every install (formatting them would cause .new conflicts)
+AGENTS.md
+CLAUDE.md
+.claude/
+docs/agent-kit/
+.github/ISSUE_TEMPLATE/
+.github/pull_request_template.md

package/presets/react-typescript/github/dependabot.yml

@@ -0,0 +1,21 @@
+version: 2
+updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 5
+    commit-message:
+      prefix: build
+      include: scope # produces "build(deps): bump ..."
+    groups:
+      dev-dependencies:
+        dependency-type: development
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+    commit-message:
+      prefix: ci
+      include: scope

package/presets/react-typescript/github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  checks:
+    name: checks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24 # adjust to your project's supported Node version
+          cache: npm
+
+      - run: npm ci
+
+      # Scripts are skipped if not defined (--if-present). Remove the flag once
+      # your project defines them, so a missing script fails the build.
+      - run: npm run lint --if-present
+      - run: npm run format:check --if-present
+      - run: npm run typecheck --if-present
+      - run: npm test --if-present
+      - run: npm run build --if-present
+
+      - name: Audit production dependencies
+        run: npm audit --omit=dev --audit-level=high

package/presets/react-typescript/github/workflows/release-please.yml

@@ -0,0 +1,21 @@
+name: release-please
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: googleapis/release-please-action@v4
+        with:
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+          # PRs opened with the default GITHUB_TOKEN do not trigger other workflows (e.g. CI).
+          # If you want CI to run on the release PR, create a PAT or GitHub App token
+          # and pass it here: token: ${{ secrets.RELEASE_PLEASE_TOKEN }}

package/presets/react-typescript/manifest.txt

@@ -0,0 +1,32 @@
+# description: React + TypeScript tooling: ESLint 9 (TS, React, Hooks, jsx-a11y), Prettier, commitlint + husky + lint-staged, react-principles skill. With --pack github: CI, release-please, Dependabot.
+
+# Commands the installer prints for the user (it never edits package.json / pyproject.toml):
+# run: npm install -D eslint@9 @eslint/js@9 typescript typescript-eslint globals eslint-plugin-react eslint-plugin-react-hooks eslint-plugin-jsx-a11y eslint-config-prettier prettier husky lint-staged @commitlint/cli @commitlint/config-conventional
+# run: npm pkg set scripts.prepare="husky" scripts.lint="eslint ." scripts.format="prettier --write ." scripts.format:check="prettier --check ." scripts.typecheck="tsc --noEmit"
+# run: npm run prepare
+
+implies    web
+
+block      react-typescript  AGENTS.md  agents-react-typescript.md
+copy       .claude/skills/react-principles/SKILL.md
+copy       eslint.config.mjs
+copy       .prettierrc.json
+block      react-typescript  .prettierignore  prettierignore.txt  style=hash
+copy       .editorconfig
+block      react-typescript  .gitignore  gitignore.txt  style=hash
+copy       .lintstagedrc.json
+copy       .husky/pre-commit
+copy       .husky/commit-msg
+copy       commitlint.config.mjs
+copy       docs/agent-kit/react-typescript.md  from=docs/react-typescript.md
+
+# GitHub-only: CI, Dependabot and release-please (release-please runs as a GitHub Action,
+# so its config and the generated CHANGELOG.md come with it; without GitHub, the
+# changelog-and-versioning skill uses manual mode).
+block      react-typescript-github  AGENTS.md  agents-react-typescript-github.md  requires=github
+copy       .github/workflows/ci.yml              requires=github  from=github/workflows/ci.yml
+copy       .github/workflows/release-please.yml  requires=github  from=github/workflows/release-please.yml
+copy       .github/dependabot.yml                requires=github  from=github/dependabot.yml
+copy       release-please-config.json            requires=github
+copy       .release-please-manifest.json         requires=github
+copy-once  CHANGELOG.md                          requires=github