@angularkit/inventory 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Gaetan / EURL ReCowd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# @angularkit/inventory
+
+Répond à la question « est-ce que ce composant existe déjà dans ma codebase ? » sans grep ni Slack.
+
+```bash
+npx @angularkit/inventory .                      # rapport sur stdout
+npx @angularkit/inventory . --md COMPONENTS.md   # catalogue à committer / donner à l'agent
+npx @angularkit/inventory . --json components.json
+```
+
+## Ce que ça sort
+
+- **Catalogue** : chaque `@Component`, son sélecteur, ses inputs/outputs (décorateurs et API signal), s'il est exporté par un `index.ts`/`public-api.ts`, combien de fois et où il est utilisé.
+- **Concepts en doublon** : `ProfileCardComponent`, `StatTile`, `OrderPanel` et `UiCard` sont regroupés sous *card* (synonymes : card/tile/panel/box, modal/dialog/popup, …).
+- **Quasi-composants** : mêmes signatures de classes CSS (≥ 4 classes) copiées-collées dans plusieurs templates — le composant qui n'a jamais été extrait.
+- **Jamais utilisés** : composants qu'aucun template ne référence (pages routées, ou code mort).
+
+## Comment ça marche
+
+Analyse statique via l'API du compilateur TypeScript (pas besoin de compiler le projet, pas besoin d'Angular installé). Zéro réseau, zéro télémétrie : rien ne sort du poste.
+
+Ignore `node_modules`, `dist`, `.nx`, `.angular`, `coverage`, `*.spec.ts`, `*.stories.ts`.
+
+## Limites connues (v0.1)
+
+- Les usages sont comptés par regex sur les templates : `<app-card` et `[appHighlight]`. Les sélecteurs de classe ou complexes sont ignorés.
+- Le clustering est lexical (nom + synonymes), pas sémantique. Il produit des faux positifs assumés : mieux vaut trop signaler que rater un doublon.
+- Un composant `templateUrl` pointant hors du projet n'est pas résolu.
+- Outil fourni « as is ».
+
+## Utilisation avec un agent
+
+Génère `COMPONENTS.md` et référence-le depuis ton `CLAUDE.md` / `AGENTS.md` :
+
+> Avant de créer un composant UI, lis `COMPONENTS.md` et réutilise l'existant.
+
+## Développement
+
+```bash
+npm ci
+npm test            # tests node:test sur le fixture
+npm run dev -- fixture
+npm run build
+```
+
+## Publier une version
+
+Tout est automatique via [release-please](https://github.com/googleapis/release-please) et les
+[Conventional Commits](https://www.conventionalcommits.org/fr/) :
+
+1. Les commits sur `main` suivent la convention : `feat: …` (version mineure), `fix: …` (patch),
+   `feat!: …` ou footer `BREAKING CHANGE:` (majeure). Les `chore:`, `docs:`, `refactor:` n'ouvrent pas de release.
+2. release-please ouvre et maintient une PR « chore(main): release X.Y.Z » qui met à jour
+   `package.json` et `CHANGELOG.md`.
+3. Merger cette PR crée le tag `vX.Y.Z`, la GitHub Release, puis publie sur npm avec provenance
+   (`.github/workflows/release.yml`).
+
+Pour forcer un numéro précis, ajouter un footer `Release-As: 1.2.3` à un commit.
+
+Mise en place, une seule fois :
+
+- **GitHub, au choix** :
+  - **Token dédié (recommandé)** : créer un PAT *fine-grained* limité à ce repo avec *Contents* et
+    *Pull requests* en lecture/écriture, et le poser en secret `RELEASE_PLEASE_TOKEN`. Avantage : la PR de
+    release déclenche la CI, ce qu'une PR ouverte avec `GITHUB_TOKEN` ne fait jamais.
+  - **Sans token** : activer *Allow GitHub Actions to create and approve pull requests* dans
+    Settings → Actions → General, d'abord au niveau de l'organisation (sinon la case est grisée dans le repo),
+    puis dans le repo.
+- **npm, au choix** :
+  - Secret `NPM_TOKEN` (automation token, bypass 2FA) dans le repo. Indispensable pour la toute première publication.
+  - Ensuite, **Trusted Publishing (recommandé, sans token)** : sur npmjs.com → package → *Settings* →
+    *Trusted Publisher* : repo `AngularKit/inventory`, workflow `release.yml`, environnement `npm`.
+    Le secret peut alors être supprimé.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { scan, toMarkdown } from './inventory.js';
+const args = process.argv.slice(2);
+const usage = `Usage: angular-inventory [dir] [--json <file>] [--md <file>] [--quiet]
+
+Scanne un projet Angular et produit l'inventaire des composants :
+sélecteurs, inputs/outputs, visibilité (API publique), usages, doublons de concept, quasi-composants.
+
+  dir            racine à scanner (défaut : .)
+  --json <file>  écrit l'inventaire JSON (ex. components.json)
+  --md <file>    écrit le rapport Markdown (ex. COMPONENTS.md)
+  --quiet        n'affiche pas le rapport sur stdout`;
+if (args.includes('--help') || args.includes('-h')) {
+    console.log(usage);
+    process.exit(0);
+}
+const opt = (name) => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] : undefined; };
+const dir = args.find((a, i) => !a.startsWith('--') && args[i - 1] !== '--json' && args[i - 1] !== '--md') ?? '.';
+const inv = scan(dir);
+const md = toMarkdown(inv);
+const jsonOut = opt('--json');
+const mdOut = opt('--md');
+if (jsonOut)
+    fs.writeFileSync(path.resolve(jsonOut), JSON.stringify(inv, null, 2));
+if (mdOut)
+    fs.writeFileSync(path.resolve(mdOut), md);
+if (!args.includes('--quiet'))
+    console.log(md);
+if (jsonOut || mdOut)
+    console.error(`\nÉcrit : ${[jsonOut, mdOut].filter(Boolean).join(', ')}`);

package/dist/inventory.d.ts

@@ -0,0 +1,35 @@
+export interface ComponentInfo {
+    className: string;
+    selectors: string[];
+    file: string;
+    templateFile?: string;
+    inputs: string[];
+    outputs: string[];
+    public: boolean;
+    usages: number;
+    usedIn: string[];
+}
+export interface Cluster {
+    concept: string;
+    components: string[];
+}
+export interface ClassPattern {
+    classes: string;
+    count: number;
+    files: string[];
+}
+export interface Inventory {
+    root: string;
+    scannedAt: string;
+    components: ComponentInfo[];
+    clusters: Cluster[];
+    quasiComponents: ClassPattern[];
+    stats: {
+        total: number;
+        public: number;
+        private: number;
+        unused: number;
+    };
+}
+export declare function scan(rootInput: string): Inventory;
+export declare function toMarkdown(inv: Inventory): string;

package/dist/inventory.js

@@ -0,0 +1,352 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import ts from 'typescript';
+// ---------- Filesystem walk ----------
+const IGNORED_DIRS = new Set([
+    'node_modules', 'dist', '.nx', '.angular', 'coverage', '.git', 'tmp', 'out-tsc', 'storybook-static',
+]);
+function walk(dir, acc = []) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            if (!IGNORED_DIRS.has(entry.name))
+                walk(path.join(dir, entry.name), acc);
+        }
+        else if (entry.isFile()) {
+            acc.push(path.join(dir, entry.name));
+        }
+    }
+    return acc;
+}
+// ---------- Decorator extraction ----------
+function decoratorsOf(node) {
+    return ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
+}
+function decoratorName(d) {
+    const e = d.expression;
+    if (ts.isCallExpression(e) && ts.isIdentifier(e.expression))
+        return e.expression.text;
+    if (ts.isIdentifier(e))
+        return e.text;
+    return undefined;
+}
+function decoratorArg(d) {
+    const e = d.expression;
+    if (ts.isCallExpression(e) && e.arguments[0] && ts.isObjectLiteralExpression(e.arguments[0])) {
+        return e.arguments[0];
+    }
+    return undefined;
+}
+function stringProp(obj, name) {
+    for (const p of obj.properties) {
+        if (ts.isPropertyAssignment(p) && p.name.getText() === name) {
+            const init = p.initializer;
+            if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init))
+                return init.text;
+        }
+    }
+    return undefined;
+}
+/** Detects `x = input(...)`, `input.required(...)`, `model(...)`, `output(...)` (signal-based APIs). */
+function signalKind(init) {
+    if (!init || !ts.isCallExpression(init))
+        return undefined;
+    const callee = init.expression;
+    let name;
+    if (ts.isIdentifier(callee))
+        name = callee.text;
+    else if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression))
+        name = callee.expression.text; // input.required
+    if (name === 'input' || name === 'model')
+        return 'input';
+    if (name === 'output' || name === 'outputFromObservable')
+        return 'output';
+    return undefined;
+}
+function extractComponents(sourceFile, root) {
+    const result = [];
+    const visit = (node) => {
+        if (ts.isClassDeclaration(node) && node.name) {
+            const dec = decoratorsOf(node).find((d) => decoratorName(d) === 'Component');
+            if (dec) {
+                const meta = decoratorArg(dec);
+                const selector = meta ? stringProp(meta, 'selector') : undefined;
+                const templateUrl = meta ? stringProp(meta, 'templateUrl') : undefined;
+                const inputs = [];
+                const outputs = [];
+                for (const m of node.members) {
+                    if (ts.isPropertyDeclaration(m) || ts.isSetAccessorDeclaration(m)) {
+                        const names = decoratorsOf(m).map(decoratorName);
+                        const prop = m.name.getText();
+                        if (names.includes('Input'))
+                            inputs.push(prop);
+                        else if (names.includes('Output'))
+                            outputs.push(prop);
+                        else if (ts.isPropertyDeclaration(m)) {
+                            const k = signalKind(m.initializer);
+                            if (k === 'input')
+                                inputs.push(prop);
+                            if (k === 'output')
+                                outputs.push(prop);
+                        }
+                    }
+                }
+                result.push({
+                    className: node.name.text,
+                    selectors: selector ? selector.split(',').map((s) => s.trim()).filter(Boolean) : [],
+                    file: path.relative(root, sourceFile.fileName),
+                    templateFile: templateUrl ? path.relative(root, path.resolve(path.dirname(sourceFile.fileName), templateUrl)) : undefined,
+                    inputs,
+                    outputs,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return result;
+}
+/** Inline templates (`template: \`...\``) of every component in a file, keyed by class name. */
+function inlineTemplates(sourceFile) {
+    const map = new Map();
+    const visit = (node) => {
+        if (ts.isClassDeclaration(node) && node.name) {
+            const dec = decoratorsOf(node).find((d) => decoratorName(d) === 'Component');
+            const meta = dec && decoratorArg(dec);
+            const tpl = meta && stringProp(meta, 'template');
+            if (tpl)
+                map.set(node.name.text, tpl);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return map;
+}
+// ---------- Public API resolution ----------
+const ENTRY_FILES = new Set(['index.ts', 'public-api.ts', 'public_api.ts']);
+function resolveModule(from, spec) {
+    if (!spec.startsWith('.'))
+        return undefined;
+    const base = path.resolve(path.dirname(from), spec);
+    const candidates = [base + '.ts', path.join(base, 'index.ts'), path.join(base, 'public-api.ts'), base];
+    return candidates.find((c) => fs.existsSync(c) && fs.statSync(c).isFile());
+}
+/** Set of files reachable through re-exports from any entry file. */
+function publicFiles(entryFiles) {
+    const seen = new Set();
+    const queue = [...entryFiles];
+    while (queue.length) {
+        const f = queue.pop();
+        if (seen.has(f))
+            continue;
+        seen.add(f);
+        const sf = ts.createSourceFile(f, fs.readFileSync(f, 'utf8'), ts.ScriptTarget.Latest, true);
+        for (const st of sf.statements) {
+            if (ts.isExportDeclaration(st) && st.moduleSpecifier && ts.isStringLiteral(st.moduleSpecifier)) {
+                const target = resolveModule(f, st.moduleSpecifier.text);
+                if (target)
+                    queue.push(target);
+            }
+        }
+    }
+    return seen;
+}
+// ---------- Usage counting ----------
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Regex matching a selector inside a template: `<app-card` or `appHighlight` as attribute. */
+function selectorRegex(selector) {
+    const attr = selector.match(/^\[([\w-]+)\]$/);
+    if (attr)
+        return new RegExp(`[\\s(\\[]\\(?\\[?${escapeRe(attr[1])}\\]?[\\s=>\\]/)]`, 'g');
+    if (/^[\w-]+$/.test(selector))
+        return new RegExp(`<${escapeRe(selector)}[\\s>/]`, 'g');
+    return undefined; // class selectors, complex selectors: skipped
+}
+// ---------- Clustering by concept ----------
+const SYNONYMS = [
+    ['card', 'tile', 'panel', 'box', 'carte', 'vignette'],
+    ['modal', 'dialog', 'popup', 'popin', 'overlay', 'drawer', 'sheet'],
+    ['button', 'btn', 'bouton', 'cta'],
+    ['input', 'field', 'champ', 'textfield'],
+    ['select', 'dropdown', 'combobox', 'picker'],
+    ['list', 'liste', 'table', 'grid', 'datagrid', 'tableau'],
+    ['toast', 'snackbar', 'notification', 'alert', 'banner', 'message'],
+    ['spinner', 'loader', 'loading', 'skeleton', 'progress'],
+    ['badge', 'chip', 'tag', 'pill', 'label'],
+    ['tabs', 'tab', 'onglet', 'stepper', 'wizard'],
+    ['nav', 'navbar', 'menu', 'sidebar', 'header', 'toolbar'],
+    ['avatar', 'icon', 'icone', 'logo', 'image'],
+    ['form', 'formulaire'],
+    ['tooltip', 'popover', 'hint'],
+    ['page', 'view', 'screen', 'container', 'layout'],
+];
+const STOPWORDS = new Set(['component', 'app', 'ui', 'lib', 'shared', 'common', 'base', 'item', 'wrapper', 'element']);
+function conceptOf(token) {
+    const t = token.toLowerCase().replace(/s$/, '');
+    for (const group of SYNONYMS)
+        if (group.includes(t))
+            return group[0];
+    return t;
+}
+function tokens(c) {
+    const src = [c.className, ...c.selectors].join(' ');
+    return src
+        .replace(/[\[\]]/g, '')
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .toLowerCase()
+        .split(/[-_\s]+/)
+        .filter((t) => t && !STOPWORDS.has(t));
+}
+function clusterComponents(components) {
+    const byConcept = new Map();
+    for (const c of components) {
+        const toks = tokens(c);
+        // Drop the most common prefix token (first token of every selector, e.g. "app")
+        for (const t of toks) {
+            const concept = conceptOf(t);
+            if (concept.length < 3)
+                continue;
+            if (!byConcept.has(concept))
+                byConcept.set(concept, new Set());
+            byConcept.get(concept).add(c.className);
+        }
+    }
+    return [...byConcept.entries()]
+        .filter(([, set]) => set.size >= 2)
+        .map(([concept, set]) => ({ concept, components: [...set].sort() }))
+        .sort((a, b) => b.components.length - a.components.length);
+}
+// ---------- Quasi-components (repeated class signatures) ----------
+function classSignatures(template) {
+    const out = [];
+    const re = /\bclass="([^"]+)"/g;
+    let m;
+    while ((m = re.exec(template))) {
+        const classes = m[1].split(/\s+/).filter(Boolean);
+        if (classes.length >= 4)
+            out.push([...new Set(classes)].sort().join(' '));
+    }
+    return out;
+}
+// ---------- Main ----------
+export function scan(rootInput) {
+    const root = path.resolve(rootInput);
+    const files = walk(root);
+    const tsFiles = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.spec.ts') && !f.endsWith('.d.ts') && !f.endsWith('.stories.ts'));
+    const htmlFiles = files.filter((f) => f.endsWith('.html'));
+    const components = [];
+    // template text by owning file (relative path) — html files + inline templates
+    const templates = new Map();
+    for (const f of htmlFiles)
+        templates.set(path.relative(root, f), fs.readFileSync(f, 'utf8'));
+    for (const f of tsFiles) {
+        const text = fs.readFileSync(f, 'utf8');
+        if (!text.includes('@Component'))
+            continue;
+        const sf = ts.createSourceFile(f, text, ts.ScriptTarget.Latest, true);
+        const found = extractComponents(sf, root);
+        const inline = inlineTemplates(sf);
+        for (const c of found) {
+            components.push({ ...c, public: false, usages: 0, usedIn: [] });
+            const tpl = inline.get(c.className);
+            if (tpl)
+                templates.set(c.file + '#' + c.className, tpl);
+        }
+    }
+    // Public API
+    const entries = tsFiles.filter((f) => ENTRY_FILES.has(path.basename(f)));
+    const pub = publicFiles(entries);
+    for (const c of components)
+        c.public = pub.has(path.join(root, c.file));
+    // Usages
+    for (const c of components) {
+        const own = new Set([c.templateFile, c.file + '#' + c.className].filter(Boolean));
+        for (const sel of c.selectors) {
+            const re = selectorRegex(sel);
+            if (!re)
+                continue;
+            for (const [tplFile, tpl] of templates) {
+                if (own.has(tplFile))
+                    continue;
+                const n = tpl.match(re)?.length ?? 0;
+                if (n > 0) {
+                    c.usages += n;
+                    const fileOnly = tplFile.split('#')[0];
+                    if (!c.usedIn.includes(fileOnly))
+                        c.usedIn.push(fileOnly);
+                }
+            }
+        }
+    }
+    // Quasi-components
+    const sigs = new Map();
+    for (const [tplFile, tpl] of templates) {
+        for (const s of classSignatures(tpl)) {
+            if (!sigs.has(s))
+                sigs.set(s, new Set());
+            sigs.get(s).add(tplFile.split('#')[0]);
+        }
+    }
+    const sigCounts = new Map();
+    for (const [, tpl] of templates)
+        for (const s of classSignatures(tpl))
+            sigCounts.set(s, (sigCounts.get(s) ?? 0) + 1);
+    const quasiComponents = [...sigs.entries()]
+        .map(([classes, fileSet]) => ({ classes, count: sigCounts.get(classes) ?? 0, files: [...fileSet].sort() }))
+        .filter((p) => p.count >= 3 && p.files.length >= 2)
+        .sort((a, b) => b.count - a.count);
+    components.sort((a, b) => a.file.localeCompare(b.file));
+    const clusters = clusterComponents(components);
+    return {
+        root,
+        scannedAt: new Date().toISOString(),
+        components,
+        clusters,
+        quasiComponents,
+        stats: {
+            total: components.length,
+            public: components.filter((c) => c.public).length,
+            private: components.filter((c) => !c.public).length,
+            unused: components.filter((c) => c.usages === 0).length,
+        },
+    };
+}
+// ---------- Markdown report ----------
+export function toMarkdown(inv) {
+    const L = [];
+    const { stats } = inv;
+    L.push(`# Inventaire des composants Angular`, '');
+    L.push(`Racine : \`${inv.root}\`  `);
+    L.push(`**${stats.total} composants** — ${stats.public} exportés (API publique), ${stats.private} privés, ${stats.unused} jamais référencés dans un template.`, '');
+    if (inv.clusters.length) {
+        L.push(`## Concepts en doublon potentiel`, '');
+        L.push(`| Concept | Nb | Composants |`, `|---|---|---|`);
+        for (const c of inv.clusters)
+            L.push(`| ${c.concept} | ${c.components.length} | ${c.components.join(', ')} |`);
+        L.push('');
+    }
+    if (inv.quasiComponents.length) {
+        L.push(`## Quasi-composants (mêmes classes CSS répétées)`, '');
+        L.push(`Signatures de classes (≥ 4 classes) répétées ≥ 3 fois dans ≥ 2 fichiers : un composant qui n'a jamais été extrait.`, '');
+        for (const q of inv.quasiComponents.slice(0, 15)) {
+            L.push(`- **×${q.count}** dans ${q.files.length} fichiers — \`${q.classes}\``);
+        }
+        L.push('');
+    }
+    L.push(`## Catalogue`, '');
+    L.push(`| Composant | Sélecteur | Public | Usages | Inputs | Outputs | Fichier |`, `|---|---|---|---|---|---|---|`);
+    for (const c of inv.components) {
+        L.push(`| ${c.className} | \`${c.selectors.join(', ') || '—'}\` | ${c.public ? '✅' : '—'} | ${c.usages} | ${c.inputs.join(', ') || '—'} | ${c.outputs.join(', ') || '—'} | ${c.file} |`);
+    }
+    L.push('');
+    const unused = inv.components.filter((c) => c.usages === 0 && c.selectors.length);
+    if (unused.length) {
+        L.push(`## Jamais utilisés dans un template`, '');
+        L.push(`Peuvent être des pages routées (normal) ou du code mort.`, '');
+        for (const c of unused)
+            L.push(`- ${c.className} (\`${c.selectors[0]}\`) — ${c.file}`);
+        L.push('');
+    }
+    return L.join('\n');
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@angularkit/inventory",
+  "version": "0.1.0",
+  "description": "Inventaire des composants d'un projet Angular : sélecteurs, inputs/outputs, API publique, usages, doublons de concept et quasi-composants.",
+  "license": "MIT",
+  "author": "Gaetan Redin (ReCowd)",
+  "type": "module",
+  "packageManager": "npm@10.9.7",
+  "bin": {
+    "angular-inventory": "./dist/cli.js"
+  },
+  "main": "./dist/inventory.js",
+  "types": "./dist/inventory.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/inventory.d.ts",
+      "default": "./dist/inventory.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "dev": "tsx src/cli.ts",
+    "test": "tsx --test test/*.test.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepack": "npm run clean && npm run build"
+  },
+  "dependencies": {
+    "typescript": "^5.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AngularKit/inventory.git"
+  },
+  "homepage": "https://github.com/AngularKit/inventory#readme",
+  "bugs": {
+    "url": "https://github.com/AngularKit/inventory/issues"
+  },
+  "keywords": [
+    "angular",
+    "components",
+    "inventory",
+    "audit",
+    "design-system",
+    "nx",
+    "ai-agents"
+  ]
+}