@slats/claude-assets-sync 0.1.4 → 0.3.0

package/bin/inject-claude-settings.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCli } from '@slats/claude-assets-sync';
+
+await runCli(process.argv);

package/dist/claude-hashes.json

@@ -0,0 +1,20 @@
+{
+  "schemaVersion": 1,
+  "package": {
+    "name": "@slats/claude-assets-sync",
+    "version": "0.3.0"
+  },
+  "generatedAt": "2026-04-24T14:51:13.873Z",
+  "algorithm": "sha256",
+  "assetRoot": "docs/claude",
+  "files": {
+    "skills/claude-docs-asset-wiring/SKILL.md": "1984ed9ea93be0e7b8eec8f77d57c455e670989c3948546d017343e321fe1b80",
+    "skills/claude-docs-asset-wiring/knowledge/claude-md-template.md": "affd92189e9d367c8717068695aca8acbadf68989a4073a8c4b1e2f4a622b72d",
+    "skills/claude-docs-asset-wiring/knowledge/dependency-cruiser.md": "18e994bd16242f72a4dc6cfa508493f4b63853a7a16c4910c7b7abd0368bd103",
+    "skills/claude-docs-asset-wiring/knowledge/gotchas.md": "9957464329cc970f6717179fad907ffad45ee4433b1d6151e20b5b3bee75b775",
+    "skills/claude-docs-asset-wiring/knowledge/package-json-patches.md": "426dcfdfdd5c02405c3d8a753b800fc90e1e9286d6f1c3c29320cf13e2645878",
+    "skills/claude-docs-asset-wiring/knowledge/reference-files.md": "3a63a095826bbfd07fae232568faf4d415dbdae0970ee4466c962ba285c3a01d",
+    "skills/claude-docs-asset-wiring/knowledge/smoke-tests.md": "c90fc82d46bf4b55d794c2ce463b4c1e199d13d6b1161028486fb4bbbd6a60fe"
+  },
+  "previousVersions": {}
+}

package/dist/commands/index.d.ts

@@ -1,112 +1 @@
-/**
- * Command registry and exports
- */
-export * from './types.js';
-export { runSyncCommand } from './sync.js';
-export { runListCommand, registerListCommand } from './list.js';
-export { runRemoveCommand } from './remove.js';
-export { runStatusCommand } from './status.js';
-export { runMigrateCommand } from './migrate.js';
-export { runAddCommand } from './add.js';
-export { runUpdateCommand } from './update.js';
-export type { UpdateCommandOptions } from './update.js';
-/**
- * Command metadata for CLI help and documentation
- */
-export declare const COMMANDS: {
-    readonly sync: {
-        readonly name: "sync";
-        readonly description: "Sync Claude assets from npm packages";
-        readonly options: readonly [{
-            readonly flag: "-p, --package <name>";
-            readonly description: "Package name to sync";
-        }, {
-            readonly flag: "-f, --force";
-            readonly description: "Force sync even if version matches";
-        }, {
-            readonly flag: "--dry-run";
-            readonly description: "Preview changes without writing files";
-        }, {
-            readonly flag: "-l, --local";
-            readonly description: "Read from local workspace";
-        }, {
-            readonly flag: "-r, --ref <ref>";
-            readonly description: "Git ref to fetch from";
-        }, {
-            readonly flag: "--no-flat";
-            readonly description: "Use legacy nested structure";
-        }];
-    };
-    readonly add: {
-        readonly name: "add";
-        readonly description: "Add a package with interactive asset selection";
-        readonly options: readonly [{
-            readonly flag: "-p, --package <name>";
-            readonly description: "Package name to add";
-        }, {
-            readonly flag: "-l, --local";
-            readonly description: "Read from local workspace";
-        }, {
-            readonly flag: "-r, --ref <ref>";
-            readonly description: "Git ref to fetch from";
-        }];
-    };
-    readonly list: {
-        readonly name: "list";
-        readonly description: "List all synced packages";
-        readonly options: readonly [{
-            readonly flag: "--json";
-            readonly description: "Output as JSON";
-        }];
-    };
-    readonly remove: {
-        readonly name: "remove";
-        readonly description: "Remove a synced package";
-        readonly options: readonly [{
-            readonly flag: "-p, --package <name>";
-            readonly description: "Package name to remove";
-        }, {
-            readonly flag: "-y, --yes";
-            readonly description: "Skip confirmation prompt";
-        }, {
-            readonly flag: "--dry-run";
-            readonly description: "Preview changes without removing files";
-        }];
-    };
-    readonly status: {
-        readonly name: "status";
-        readonly description: "Show sync status of all packages";
-        readonly options: readonly [{
-            readonly flag: "--no-remote";
-            readonly description: "Skip remote version check";
-        }];
-    };
-    readonly migrate: {
-        readonly name: "migrate";
-        readonly description: "Migrate from legacy to flat structure";
-        readonly options: readonly [{
-            readonly flag: "--dry-run";
-            readonly description: "Preview migration without making changes";
-        }];
-    };
-    readonly update: {
-        readonly name: "update";
-        readonly description: "Update package metadata in .sync-meta.json";
-        readonly options: readonly [{
-            readonly flag: "-p, --package <name>";
-            readonly description: "Package name to update (default: all)";
-        }, {
-            readonly flag: "-l, --local";
-            readonly description: "Read from local workspace";
-        }, {
-            readonly flag: "-r, --ref <ref>";
-            readonly description: "Git ref to fetch from";
-        }, {
-            readonly flag: "--dry-run";
-            readonly description: "Preview changes without writing";
-        }, {
-            readonly flag: "--sync";
-            readonly description: "Re-sync files after updating metadata";
-        }];
-    };
-};
+export { runCli, type DefaultFlags } from './runCli/index.js';

package/dist/commands/runCli/index.d.ts

@@ -0,0 +1,2 @@
+export { runCli } from './runCli.js';
+export type { DefaultFlags } from './type.js';

package/dist/commands/runCli/runCli.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var commander = require('commander');
+var logger = require('../../utils/logger.cjs');
+var version = require('../../utils/version.cjs');
+var resolveTargets = require('./utils/resolveTargets.cjs');
+var runInject = require('./utils/runInject.cjs');
+
+async function runCli(argv = process.argv) {
+    const cmd = new commander.Command();
+    cmd
+        .name('inject-claude-settings')
+        .description("Inject target consumer(s)' Claude assets into the selected .claude directory")
+        .version(version.VERSION)
+        .option('--package <name...>', 'Target(s). "@<scope>" = whole npm scope; "@<scope>/<name>" or "<name>" = one package. Repeat the flag or comma-separate values.', collectPackageValues, [])
+        .option('--scope <scope>', 'Target scope: user (~/.claude) | project (nearest ancestor .claude or <cwd>/.claude)')
+        .option('--dry-run', 'Preview without writing', false)
+        .option('--force', 'Overwrite user modifications', false)
+        .option('--root <path>', 'Override scope resolution cwd (default: cwd)')
+        .action(async (flags) => {
+        const targets = flags.package ?? [];
+        if (targets.length === 0) {
+            logger.logger.error('missing required flag: --package <name> (e.g. --package=@canard/schema-form or --package=@canard)');
+            process.exit(2);
+        }
+        const originCwd = flags.root ?? process.cwd();
+        const metadataList = await resolveTargets.resolveTargets(targets, originCwd);
+        if (metadataList.length === 0) {
+            logger.logger.warn(`no packages resolved from --package target(s): ${targets.join(', ')}`);
+            return;
+        }
+        await runInject.runInject(flags, metadataList);
+    });
+    try {
+        await cmd.parseAsync([...argv]);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.logger.error(msg);
+        process.exit(1);
+    }
+}
+function collectPackageValues(value, previous = []) {
+    return [
+        ...previous,
+        ...value
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean),
+    ];
+}
+
+exports.runCli = runCli;

package/dist/commands/runCli/runCli.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CLI entry for `@slats/claude-assets-sync`.
+ *
+ * The `inject-claude-settings` dispatcher parses `--package <name...>`
+ * from argv and classifies each value:
+ * - `@<scope>` — enumerate every workspace package under that scope
+ * - `@<scope>/<name>` — one scoped package
+ * - `<name>` — one unscoped package
+ *
+ * Targets are resolved via Node module resolution (`resolvePackage`)
+ * except for scope aliases, which are the only path allowed to walk
+ * the monorepo — that exception is isolated to `resolveScopeAlias.ts`.
+ */
+export declare function runCli(argv?: readonly string[]): Promise<void>;

package/dist/commands/runCli/runCli.mjs

@@ -0,0 +1,51 @@
+import { Command } from 'commander';
+import { logger } from '../../utils/logger.mjs';
+import { VERSION } from '../../utils/version.mjs';
+import { resolveTargets } from './utils/resolveTargets.mjs';
+import { runInject } from './utils/runInject.mjs';
+
+async function runCli(argv = process.argv) {
+    const cmd = new Command();
+    cmd
+        .name('inject-claude-settings')
+        .description("Inject target consumer(s)' Claude assets into the selected .claude directory")
+        .version(VERSION)
+        .option('--package <name...>', 'Target(s). "@<scope>" = whole npm scope; "@<scope>/<name>" or "<name>" = one package. Repeat the flag or comma-separate values.', collectPackageValues, [])
+        .option('--scope <scope>', 'Target scope: user (~/.claude) | project (nearest ancestor .claude or <cwd>/.claude)')
+        .option('--dry-run', 'Preview without writing', false)
+        .option('--force', 'Overwrite user modifications', false)
+        .option('--root <path>', 'Override scope resolution cwd (default: cwd)')
+        .action(async (flags) => {
+        const targets = flags.package ?? [];
+        if (targets.length === 0) {
+            logger.error('missing required flag: --package <name> (e.g. --package=@canard/schema-form or --package=@canard)');
+            process.exit(2);
+        }
+        const originCwd = flags.root ?? process.cwd();
+        const metadataList = await resolveTargets(targets, originCwd);
+        if (metadataList.length === 0) {
+            logger.warn(`no packages resolved from --package target(s): ${targets.join(', ')}`);
+            return;
+        }
+        await runInject(flags, metadataList);
+    });
+    try {
+        await cmd.parseAsync([...argv]);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.error(msg);
+        process.exit(1);
+    }
+}
+function collectPackageValues(value, previous = []) {
+    return [
+        ...previous,
+        ...value
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean),
+    ];
+}
+
+export { runCli };

package/dist/commands/runCli/type.d.ts

@@ -0,0 +1,19 @@
+export interface DefaultFlags {
+    scope?: string;
+    dryRun?: boolean;
+    force?: boolean;
+    root?: string;
+    package?: string[];
+}
+/**
+ * Resolved consumer metadata passed to the injection pipeline.
+ * The dispatcher bin populates this by resolving a single explicitly-named
+ * target package — `core/**` still never reads `package.json` itself.
+ */
+export interface ConsumerPackage {
+    name: string;
+    version: string;
+    packageRoot: string;
+    assetRoot: string;
+    hashesPresent: boolean;
+}

package/dist/commands/runCli/utils/classifyTarget.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+const NPM_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+function classifyTarget(target) {
+    if (typeof target !== 'string' || target.length === 0) {
+        return { kind: 'invalid', reason: 'empty --package value' };
+    }
+    if (target.startsWith('@')) {
+        const body = target.slice(1);
+        const slashIndex = body.indexOf('/');
+        if (slashIndex === -1) {
+            if (!NPM_NAME_PATTERN.test(body)) {
+                return {
+                    kind: 'invalid',
+                    reason: `invalid scope alias "${target}" — expected "@<scope>" with lowercase alphanumerics, ".", "-", or "_"`,
+                };
+            }
+            return { kind: 'scope', scope: body };
+        }
+        const scopePart = body.slice(0, slashIndex);
+        const namePart = body.slice(slashIndex + 1);
+        if (!NPM_NAME_PATTERN.test(scopePart) ||
+            namePart.length === 0 ||
+            namePart.includes('/') ||
+            !NPM_NAME_PATTERN.test(namePart)) {
+            return {
+                kind: 'invalid',
+                reason: `invalid scoped package "${target}" — expected "@<scope>/<name>"`,
+            };
+        }
+        return { kind: 'package', name: target };
+    }
+    if (target.includes('/')) {
+        return {
+            kind: 'invalid',
+            reason: `invalid target "${target}" — unscoped package names cannot contain "/"`,
+        };
+    }
+    if (!NPM_NAME_PATTERN.test(target)) {
+        return {
+            kind: 'invalid',
+            reason: `invalid package name "${target}" — expected lowercase alphanumerics, ".", "-", or "_"`,
+        };
+    }
+    return { kind: 'package', name: target };
+}
+
+exports.classifyTarget = classifyTarget;

package/dist/commands/runCli/utils/classifyTarget.d.ts

@@ -0,0 +1,19 @@
+export type ClassifiedTarget = {
+    kind: 'scope';
+    scope: string;
+} | {
+    kind: 'package';
+    name: string;
+} | {
+    kind: 'invalid';
+    reason: string;
+};
+/**
+ * Classify a `--package` value as a scope alias, a package name, or invalid.
+ *
+ * - `@<scope>` (no slash) — all packages under that npm scope
+ * - `@<scope>/<name>` — one scoped package
+ * - `<name>` (no `@`, no slash) — one unscoped package
+ * - anything else → invalid
+ */
+export declare function classifyTarget(target: string): ClassifiedTarget;

package/dist/commands/runCli/utils/classifyTarget.mjs

@@ -0,0 +1,46 @@
+const NPM_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+function classifyTarget(target) {
+    if (typeof target !== 'string' || target.length === 0) {
+        return { kind: 'invalid', reason: 'empty --package value' };
+    }
+    if (target.startsWith('@')) {
+        const body = target.slice(1);
+        const slashIndex = body.indexOf('/');
+        if (slashIndex === -1) {
+            if (!NPM_NAME_PATTERN.test(body)) {
+                return {
+                    kind: 'invalid',
+                    reason: `invalid scope alias "${target}" — expected "@<scope>" with lowercase alphanumerics, ".", "-", or "_"`,
+                };
+            }
+            return { kind: 'scope', scope: body };
+        }
+        const scopePart = body.slice(0, slashIndex);
+        const namePart = body.slice(slashIndex + 1);
+        if (!NPM_NAME_PATTERN.test(scopePart) ||
+            namePart.length === 0 ||
+            namePart.includes('/') ||
+            !NPM_NAME_PATTERN.test(namePart)) {
+            return {
+                kind: 'invalid',
+                reason: `invalid scoped package "${target}" — expected "@<scope>/<name>"`,
+            };
+        }
+        return { kind: 'package', name: target };
+    }
+    if (target.includes('/')) {
+        return {
+            kind: 'invalid',
+            reason: `invalid target "${target}" — unscoped package names cannot contain "/"`,
+        };
+    }
+    if (!NPM_NAME_PATTERN.test(target)) {
+        return {
+            kind: 'invalid',
+            reason: `invalid package name "${target}" — expected lowercase alphanumerics, ".", "-", or "_"`,
+        };
+    }
+    return { kind: 'package', name: target };
+}
+
+export { classifyTarget };

package/dist/commands/runCli/utils/injectOne.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+require('node:crypto');
+require('node:fs/promises');
+require('node:path');
+var injectDocs = require('../../../core/injectDocs/injectDocs.cjs');
+require('node:os');
+require('node:fs');
+require('@inquirer/prompts');
+require('picocolors');
+var confirmForce = require('../../../prompts/confirmForce.cjs');
+var heartbeat = require('../../../utils/heartbeat.cjs');
+var logger = require('../../../utils/logger.cjs');
+
+async function injectOne(target, scope, flags, originCwd) {
+    if (!target.hashesPresent) {
+        logger.logger.warn(`${target.name}: dist/claude-hashes.json missing — build the package (e.g. yarn build) to regenerate the hash manifest first.`);
+        return 0;
+    }
+    logger.logger.heading(`${target.name}@${target.version}`);
+    const stopHeartbeat = heartbeat.startHeartbeat({
+        label: `injecting ${target.name}`,
+    });
+    try {
+        const report = await injectDocs.injectDocs({
+            packageName: target.name,
+            packageVersion: target.version,
+            packageRoot: target.packageRoot,
+            assetRoot: target.assetRoot,
+            scope,
+            originCwd,
+            dryRun: flags.dryRun ?? false,
+            force: flags.force ?? false,
+            confirmForce: async (plan) => {
+                const diverged = plan.actions.filter((a) => a.kind === 'warn-diverged');
+                const orphans = plan.actions.filter((a) => a.kind === 'warn-orphan');
+                return confirmForce.confirmForceAsync(diverged.length, orphans.length, [...diverged, ...orphans].map((a) => a.relPath).slice(0, 3));
+            },
+        });
+        return report.exitCode;
+    }
+    finally {
+        stopHeartbeat();
+    }
+}
+
+exports.injectOne = injectOne;

package/dist/commands/runCli/utils/injectOne.d.ts

@@ -0,0 +1,3 @@
+import { type Scope } from '../../../core/index.js';
+import type { ConsumerPackage, DefaultFlags } from '../type.js';
+export declare function injectOne(target: ConsumerPackage, scope: Scope, flags: DefaultFlags, originCwd: string): Promise<number>;

package/dist/commands/runCli/utils/injectOne.mjs

@@ -0,0 +1,45 @@
+import 'node:crypto';
+import 'node:fs/promises';
+import 'node:path';
+import { injectDocs } from '../../../core/injectDocs/injectDocs.mjs';
+import 'node:os';
+import 'node:fs';
+import '@inquirer/prompts';
+import 'picocolors';
+import { confirmForceAsync } from '../../../prompts/confirmForce.mjs';
+import { startHeartbeat } from '../../../utils/heartbeat.mjs';
+import { logger } from '../../../utils/logger.mjs';
+
+async function injectOne(target, scope, flags, originCwd) {
+    if (!target.hashesPresent) {
+        logger.warn(`${target.name}: dist/claude-hashes.json missing — build the package (e.g. yarn build) to regenerate the hash manifest first.`);
+        return 0;
+    }
+    logger.heading(`${target.name}@${target.version}`);
+    const stopHeartbeat = startHeartbeat({
+        label: `injecting ${target.name}`,
+    });
+    try {
+        const report = await injectDocs({
+            packageName: target.name,
+            packageVersion: target.version,
+            packageRoot: target.packageRoot,
+            assetRoot: target.assetRoot,
+            scope,
+            originCwd,
+            dryRun: flags.dryRun ?? false,
+            force: flags.force ?? false,
+            confirmForce: async (plan) => {
+                const diverged = plan.actions.filter((a) => a.kind === 'warn-diverged');
+                const orphans = plan.actions.filter((a) => a.kind === 'warn-orphan');
+                return confirmForceAsync(diverged.length, orphans.length, [...diverged, ...orphans].map((a) => a.relPath).slice(0, 3));
+            },
+        });
+        return report.exitCode;
+    }
+    finally {
+        stopHeartbeat();
+    }
+}
+
+export { injectOne };

package/dist/commands/runCli/utils/resolvePackage.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var promises = require('node:fs/promises');
+var node_module = require('node:module');
+var node_path = require('node:path');
+var logger = require('../../../utils/logger.cjs');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+async function resolvePackage(name, options = {}) {
+    const pkgJsonPath = resolvePackageJsonPath(name);
+    if (!pkgJsonPath) {
+        logger.logger.error(`cannot resolve package "${name}". Install it in the current project or pass the correct name.`);
+        process.exit(2);
+    }
+    const packageRoot = node_path.dirname(pkgJsonPath);
+    const raw = await promises.readFile(pkgJsonPath, 'utf-8');
+    const pkg = JSON.parse(raw);
+    if (typeof pkg.name !== 'string' || typeof pkg.version !== 'string') {
+        if (options.skipMissingAsset) {
+            logger.logger.warn(`"${name}" package.json is missing a string "name" or "version" — skipping.`);
+            return null;
+        }
+        logger.logger.error(`${pkgJsonPath} must define string "name" and "version".`);
+        process.exit(2);
+    }
+    const assetPath = pkg.claude?.assetPath;
+    if (typeof assetPath !== 'string' || assetPath.length === 0) {
+        if (options.skipMissingAsset) {
+            logger.logger.warn(`"${name}" is missing "claude.assetPath" — skipping (the package does not ship Claude assets).`);
+            return null;
+        }
+        logger.logger.error(`"${name}" is missing "claude.assetPath" in its package.json — the package does not ship Claude assets.`);
+        process.exit(2);
+    }
+    return {
+        packageRoot,
+        packageName: pkg.name,
+        packageVersion: pkg.version,
+        assetPath,
+    };
+}
+function resolvePackageJsonPath(name) {
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('commands/runCli/utils/resolvePackage.cjs', document.baseURI).href)));
+    try {
+        return require$1.resolve(`${name}/package.json`);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED')
+            return null;
+    }
+    let mainEntry;
+    try {
+        mainEntry = require$1.resolve(name);
+    }
+    catch {
+        return null;
+    }
+    let dir = node_path.dirname(mainEntry);
+    while (dir && dir !== node_path.dirname(dir)) {
+        const candidate = node_path.resolve(dir, 'package.json');
+        if (node_fs.existsSync(candidate)) {
+            try {
+                const pkg = JSON.parse(node_fs.readFileSync(candidate, 'utf-8'));
+                if (pkg.name === name)
+                    return candidate;
+            }
+            catch {
+            }
+        }
+        dir = node_path.dirname(dir);
+    }
+    return null;
+}
+
+exports.resolvePackage = resolvePackage;

package/dist/commands/runCli/utils/resolvePackage.d.ts

@@ -0,0 +1,16 @@
+export interface ResolvedMetadata {
+    packageRoot: string;
+    packageName: string;
+    packageVersion: string;
+    assetPath: string;
+}
+export interface ResolvePackageOptions {
+    /**
+     * When `true`, a package without `claude.assetPath` is warned and the
+     * function returns `null` instead of calling `process.exit`. Default
+     * `false` preserves the v0.3.0 strict behavior for single-target
+     * dispatcher calls.
+     */
+    skipMissingAsset?: boolean;
+}
+export declare function resolvePackage(name: string, options?: ResolvePackageOptions): Promise<ResolvedMetadata | null>;

package/dist/commands/runCli/utils/resolvePackage.mjs

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import { logger } from '../../../utils/logger.mjs';
+
+async function resolvePackage(name, options = {}) {
+    const pkgJsonPath = resolvePackageJsonPath(name);
+    if (!pkgJsonPath) {
+        logger.error(`cannot resolve package "${name}". Install it in the current project or pass the correct name.`);
+        process.exit(2);
+    }
+    const packageRoot = dirname(pkgJsonPath);
+    const raw = await readFile(pkgJsonPath, 'utf-8');
+    const pkg = JSON.parse(raw);
+    if (typeof pkg.name !== 'string' || typeof pkg.version !== 'string') {
+        if (options.skipMissingAsset) {
+            logger.warn(`"${name}" package.json is missing a string "name" or "version" — skipping.`);
+            return null;
+        }
+        logger.error(`${pkgJsonPath} must define string "name" and "version".`);
+        process.exit(2);
+    }
+    const assetPath = pkg.claude?.assetPath;
+    if (typeof assetPath !== 'string' || assetPath.length === 0) {
+        if (options.skipMissingAsset) {
+            logger.warn(`"${name}" is missing "claude.assetPath" — skipping (the package does not ship Claude assets).`);
+            return null;
+        }
+        logger.error(`"${name}" is missing "claude.assetPath" in its package.json — the package does not ship Claude assets.`);
+        process.exit(2);
+    }
+    return {
+        packageRoot,
+        packageName: pkg.name,
+        packageVersion: pkg.version,
+        assetPath,
+    };
+}
+function resolvePackageJsonPath(name) {
+    const require = createRequire(import.meta.url);
+    try {
+        return require.resolve(`${name}/package.json`);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED')
+            return null;
+    }
+    let mainEntry;
+    try {
+        mainEntry = require.resolve(name);
+    }
+    catch {
+        return null;
+    }
+    let dir = dirname(mainEntry);
+    while (dir && dir !== dirname(dir)) {
+        const candidate = resolve(dir, 'package.json');
+        if (existsSync(candidate)) {
+            try {
+                const pkg = JSON.parse(readFileSync(candidate, 'utf-8'));
+                if (pkg.name === name)
+                    return candidate;
+            }
+            catch {
+            }
+        }
+        dir = dirname(dir);
+    }
+    return null;
+}
+
+export { resolvePackage };