@slats/claude-assets-sync 0.1.4 → 0.3.0

package/docs/claude/skills/claude-docs-asset-wiring/knowledge/smoke-tests.md

@@ -0,0 +1,111 @@
+# E2E Smoke Tests — 8-path matrix via engine dispatcher
+
+**Run from `/tmp/...` — never from the monorepo root or `${TARGET_PATH}/`.**
+
+`--scope=project` walks `cwd` upward looking for an existing `.claude`
+directory. Running from the monorepo would reuse or mutate the real
+repo's `.claude`, which is a destructive error.
+
+No fake `node_modules` needed — the engine uses
+`createRequire(import.meta.url).resolve(`${PACKAGE_NAME}/package.json`)`
+from the engine's own installed location.
+
+---
+
+## Setup
+
+```bash
+BIN="$PWD/packages/slats/claude-assets-sync/bin/inject-claude-settings.mjs"
+DIR=/tmp/inject-smoke-${SHORTCUT:-target}
+[ -d "$DIR" ] && find "$DIR" -mindepth 1 -delete
+mkdir -p "$DIR" && cd "$DIR"
+```
+
+`[ -d ... ] && find -delete` keeps the setup idempotent. **Never** use
+`rm -rf` or unquoted `*` globs — too easy to nuke the wrong directory.
+
+---
+
+## Matrix
+
+Execute sequentially. `EXIT=$?` after each so the value is captured
+before the next command overwrites `$?`.
+
+| #  | Command                                                                                          | Expected exit | Purpose                                                      |
+|----|--------------------------------------------------------------------------------------------------|---------------|--------------------------------------------------------------|
+|  1 | `node "$BIN" --package=${PACKAGE_NAME} --scope=project --dry-run`                                | 0             | Dry run — previews actions, no writes.                       |
+|  2 | `node "$BIN" --package=${PACKAGE_NAME} --scope=project`                                          | 0             | First real install — writes `.claude/` under `$DIR`.         |
+|  3 | `node "$BIN" --package=${PACKAGE_NAME} --scope=project`                                          | 0             | Re-run — no-op (idempotent).                                 |
+|  4 | (after tampering) `CI=true node "$BIN" --package=${PACKAGE_NAME} --scope=project`                | **2**         | CI + tampered content → refuse to overwrite.                 |
+|  5 | `CI=true node "$BIN" --package=${PACKAGE_NAME} --scope=project --force`                          | 0             | `--force` overrides the refusal.                             |
+|  6 | `CI=true node "$BIN" --package=${PACKAGE_NAME}`                                                  | **2**         | Missing `--scope` in non-TTY context.                        |
+|  7 | `node "$BIN"`                                                                                    | **2**         | Missing `--package` (dispatcher-specific).                   |
+|  8 | `node "$BIN" --package=@does/not-exist`                                                          | **2**         | Unresolvable package (dispatcher-specific).                  |
+
+### Tamper step (between path 3 and path 4)
+
+```bash
+find .claude -name SKILL.md -exec sh -c 'echo tampered >> "$1"' _ {} \;
+```
+
+Appends `tampered` to every `SKILL.md` under the local `.claude/`.
+Simulates a human edit that the CI-mode dispatcher must detect and
+refuse to clobber.
+
+---
+
+## Execution Shape
+
+Split into **two bash calls** because `cwd` resets between Bash tool
+invocations.
+
+**First call** — paths 1–3:
+
+```bash
+BIN="$PWD/packages/slats/claude-assets-sync/bin/inject-claude-settings.mjs"
+DIR=/tmp/inject-smoke-${SHORTCUT:-target}
+[ -d "$DIR" ] && find "$DIR" -mindepth 1 -delete
+mkdir -p "$DIR" && cd "$DIR"
+
+node "$BIN" --package=${PACKAGE_NAME} --scope=project --dry-run; echo "EXIT=$?"
+node "$BIN" --package=${PACKAGE_NAME} --scope=project;           echo "EXIT=$?"
+node "$BIN" --package=${PACKAGE_NAME} --scope=project;           echo "EXIT=$?"
+```
+
+**Second call** — paths 4–8:
+
+```bash
+DIR=/tmp/inject-smoke-${SHORTCUT:-target}
+BIN="$PWD/packages/slats/claude-assets-sync/bin/inject-claude-settings.mjs"
+cd "$DIR"
+
+find .claude -name SKILL.md -exec sh -c 'echo tampered >> "$1"' _ {} \;
+CI=true node "$BIN" --package=${PACKAGE_NAME} --scope=project;         echo "EXIT=$?"
+CI=true node "$BIN" --package=${PACKAGE_NAME} --scope=project --force; echo "EXIT=$?"
+CI=true node "$BIN" --package=${PACKAGE_NAME};                         echo "EXIT=$?"
+node "$BIN";                                                            echo "EXIT=$?"
+node "$BIN" --package=@does/not-exist;                                 echo "EXIT=$?"
+```
+
+Note: `$PWD` in the second call is the parent shell's cwd (monorepo
+root), so `BIN` resolves correctly. `cd "$DIR"` then moves into the
+smoke directory before invoking.
+
+---
+
+## Failure Handling
+
+| Observed | Meaning                                                                 | Action                                                             |
+|----------|-------------------------------------------------------------------------|--------------------------------------------------------------------|
+| 1 ≠ 0    | Dry-run crashed. Likely an engine bug or bad `claude.assetPath`.        | Stop, capture stderr, report.                                      |
+| 2 ≠ 0    | First write failed. Permissions, engine bug, or manifest issue.         | Stop, inspect `dist/claude-hashes.json`, report.                   |
+| 3 ≠ 0    | Idempotency broken — re-run should be no-op.                            | Stop, diff `$DIR/.claude` before/after, report.                    |
+| 4 = 0    | CI mode did not refuse tampered files. Safety regression.               | Stop — the engine's CI gate is broken.                             |
+| 5 ≠ 0    | `--force` failed to override. Check engine.                             | Stop, report.                                                      |
+| 6 = 0    | Engine defaulted a scope in non-TTY context. Should require `--scope`.  | Stop, report.                                                      |
+| 7 = 0    | Dispatcher accepted no `--package`. Violates contract.                  | Stop — dispatcher bug.                                             |
+| 8 = 0    | Dispatcher succeeded on unresolvable package. Violates contract.        | Stop — dispatcher bug.                                             |
+
+Do not attempt to "make the tests pass" by altering expectations. The
+matrix encodes invariants of the engine — a mismatch is a real
+regression upstream.

package/docs/consumer-integration.md

@@ -0,0 +1,94 @@
+# Consumer Integration Template
+
+How to make a package ship Claude Code assets through the `inject-claude-settings` dispatcher. Two fields in `package.json`; no stub code.
+
+## 1. `package.json` additions
+
+```jsonc
+{
+  "name": "@your-scope/your-package",
+  "version": "…",
+  "scripts": {
+    "build": "… && yarn build:hashes",
+    "build:hashes": "claude-build-hashes"
+  },
+  "dependencies": {
+    "@slats/claude-assets-sync": "workspace:^"
+  },
+  "files": ["dist", "docs", "README.md"],
+  "claude": {
+    "assetPath": "docs/claude"
+  }
+}
+```
+
+- `@slats/claude-assets-sync` MUST be in `dependencies`, not `devDependencies` or `peerDependencies`.
+- Do **not** add any `bin` field. Bin names collide across consumers under `node_modules/.bin/` and the engine is the sole CLI surface.
+- Do **not** expose `./bin/*` or `./docs/*` in `exports`. Exposing them would let bundlers pull CLI code or the docs tree into app bundles.
+- Do **not** create a `bin/` or `scripts/` directory in the consumer. The engine's `claude-build-hashes` bin (resolved via `node_modules/.bin/`) handles build-time hashing.
+
+## 2. `docs/claude/` authoring
+
+Any file tree works, but the recommended layout is:
+
+```
+docs/claude/
+├── skills/
+│   └── <skill-name>/
+│       ├── SKILL.md
+│       └── knowledge/...
+├── rules/...
+└── commands/...
+```
+
+The build step (`yarn build:hashes` → `claude-build-hashes`) hashes every file under `docs/claude/` relative to the asset root and writes `dist/claude-hashes.json`. On inject, the CLI copies `skills`/`rules`/`commands` into the matching subtree under `.claude/`.
+
+## 3. Isolation guardrails (optional but recommended)
+
+In a `.dependency-cruiser.cjs`:
+
+```javascript
+{
+  name: 'src-no-docs',
+  severity: 'error',
+  comment:
+    'src/ must not import from docs/. docs/claude/** contains pure markdown ' +
+    'assets meant only for the engine dispatcher, not for the library runtime.',
+  from: { path: '^src/' },
+  to: { path: '^docs/' },
+},
+```
+
+Plus `"sideEffects": false` in `package.json`. These ensure the docs tree never leaks into consumer runtime bundles.
+
+The legacy `src-no-bin` and `src-no-claude-assets-sync` rules are no longer load-bearing — the consumer owns no `bin/`, and the engine isn't referenced from `src/` anyway. Do not reintroduce them.
+
+## 4. End-user invocations
+
+| Install topology | Invocation |
+|---|---|
+| End user installs consumer as a **direct dep** on npm / yarn-classic | `npx inject-claude-settings --package=@your-scope/your-package --scope=user` |
+| End user installs consumer as a **direct dep** on pnpm strict / yarn-berry PnP | `npx -p @slats/claude-assets-sync inject-claude-settings --package=@your-scope/your-package --scope=user` |
+| End user has **no consumer installed** yet | `npx -p @slats/claude-assets-sync inject-claude-settings --package=@your-scope/your-package --scope=user` (resolves to whatever is on the registry under that exact name) |
+| End user has **multiple consumers installed** | Call `inject-claude-settings --package=<one-name>` per target. There is no `--all`. |
+
+### Scope resolution (project)
+
+For `--scope=project`, the target `.claude` directory is resolved by walking up from `process.cwd()` and reusing the first existing `.claude` directory found. Only if no ancestor owns a `.claude` does the CLI fall back to `process.cwd()/.claude`. The CLI logs `(auto-located)` when this happens.
+
+```
+workspace/
+  .claude/                        ← reused target (auto-located)
+  packages/
+    @your-scope/your-package/     ← cd here and run inject-claude-settings
+```
+
+Running `inject-claude-settings --package=@your-scope/your-package --scope=project` from `packages/@your-scope/your-package/` injects into `workspace/.claude`, not `packages/@your-scope/your-package/.claude`.
+
+## 5. Verification checklist
+
+- [ ] `yarn build` succeeds and emits `dist/claude-hashes.json` alongside the rest of `dist/`.
+- [ ] `node packages/slats/claude-assets-sync/bin/inject-claude-settings.mjs --help` prints the dispatcher usage.
+- [ ] `node packages/slats/claude-assets-sync/bin/inject-claude-settings.mjs --package=@your-scope/your-package --scope=project --dry-run` emits a copy plan when run from `/tmp/...`.
+- [ ] If you enabled Section 3's depcheck, `yarn depcheck` reports zero violations.
+- [ ] Consumer bundler tree-shakes away docs — grep the built bundle for `@slats/claude-assets-sync`, `inject-claude-settings`, and `docs/claude`; all three should be absent.

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@slats/claude-assets-sync",
-  "version": "0.1.4",
-  "description": "CLI tool to sync Claude commands and skills from npm packages to your project's .claude directory",
+  "version": "0.3.0",
+  "description": "Shared CLI engine that lets consumer packages inject their Claude docs (skills, rules, commands) into a user's .claude directory via a thin bin/inject-docs wrapper.",
   "keywords": [
     "claude",
     "claude-code",
     "cli",
-    "sync",
-    "commands",
+    "inject",
+    "docs",
     "skills",
     "assets"
   ],
@@ -29,23 +29,34 @@
       "source": "./src/index.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
+    },
+    "./buildHashes": {
+      "import": "./scripts/buildHashes.mjs"
     }
   },
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "bin": "./dist/cli.mjs",
+  "bin": {
+    "claude-build-hashes": "./scripts/claude-build-hashes.mjs",
+    "inject-claude-settings": "./bin/inject-claude-settings.mjs"
+  },
   "files": [
     "dist",
+    "docs",
+    "bin",
+    "scripts",
     "README.md"
   ],
   "scripts": {
-    "build": "node scripts/inject-version.js && rollup -c && yarn build:types",
+    "build": "node scripts/inject-version.js && rollup -c && yarn build:types && yarn build:hashes",
+    "build:hashes": "node scripts/build-hashes.mjs",
     "build:publish:npm": "yarn build && yarn publish:npm",
     "build:types": "node ../../aileron/script/build/buildTypes.mjs",
-    "dev": "node scripts/inject-version.js && tsx src/cli.ts",
+    "dev": "node scripts/inject-version.js && tsx src/main.ts",
     "format": "prettier --write \"src/**/*.ts\"",
     "lint": "eslint \"src/**/*.ts\"",
+    "prepublishOnly": "yarn build",
     "publish:npm": "yarn npm publish --access public",
     "test": "vitest",
     "version:major": "yarn version major",
@@ -53,17 +64,14 @@
     "version:patch": "yarn version patch"
   },
   "dependencies": {
-    "@winglet/react-utils": "^0.11.2",
+    "@inquirer/prompts": "^8.4.2",
     "commander": "^12.1.0",
-    "ink": "^6.6.0",
-    "ink-select-input": "^6.2.0",
-    "ink-spinner": "^5.0.0",
-    "picocolors": "^1.1.1",
-    "react": "^19.1.1",
-    "react-dom": "^19.1.1"
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
-    "@types/react": "^19.0.0",
-    "ink-testing-library": "^4.0.0"
+    "@inquirer/testing": "^3.3.5"
+  },
+  "claude": {
+    "assetPath": "docs/claude"
   }
 }

package/scripts/build-hashes.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// Thin wrapper — parses this package's package.json and delegates to
+// @slats/claude-assets-sync/buildHashes. The `claude.assetPath` convention
+// lives here, in the consumer; the library is generic.
+import { buildHashes } from '@slats/claude-assets-sync/buildHashes';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const pkg = JSON.parse(
+  await readFile(resolve(packageRoot, 'package.json'), 'utf-8'),
+);
+
+if (typeof pkg.claude?.assetPath === 'string') {
+  try {
+    const { outPath, fileCount } = await buildHashes({
+      packageRoot,
+      packageName: pkg.name,
+      packageVersion: pkg.version,
+      assetPath: pkg.claude.assetPath,
+    });
+    console.log(
+      `✓ claude-hashes.json written: ${fileCount} file(s) → ${outPath}`,
+    );
+  } catch (err) {
+    console.error('❌ build-hashes failed:', err?.message ?? err);
+    process.exit(1);
+  }
+}

package/scripts/buildHashes.d.mts

@@ -0,0 +1,15 @@
+export interface BuildHashesOptions {
+  packageRoot?: string;
+  packageName?: string;
+  packageVersion?: string;
+  assetPathRel?: string;
+}
+
+export interface BuildHashesResult {
+  outPath: string;
+  fileCount: number;
+}
+
+export function buildHashes(
+  opts?: BuildHashesOptions,
+): Promise<BuildHashesResult>;

package/scripts/buildHashes.mjs

@@ -0,0 +1,82 @@
+// Library + importable implementation for the hash manifest builder.
+//
+// Self-executing CLI behavior lives in `./claude-build-hashes.mjs` so this
+// file stays free of top-level await and can be bundled into CJS/ESM outputs
+// via Rollup without format errors.
+//
+// Exported for:
+//   - Consumer packages: `import { buildHashes } from '@slats/claude-assets-sync/buildHashes'`
+//   - Standalone bin: `./claude-build-hashes.mjs`
+//
+// The caller owns all package metadata. This function does not read
+// package.json — consumers parse their own manifest and pass a ready-made
+// set of values so the library stays free of field-shape assumptions.
+
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+
+const MANIFEST_FILENAME = 'claude-hashes.json';
+const NOISE = [/(^|\/)\.omc(\/|$)/, /(^|\/)\.DS_Store$/, /\.log$/];
+
+const toPosix = (p) => (sep === '/' ? p : p.split(sep).join('/'));
+
+async function* walk(root) {
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === 'ENOENT') return;
+    throw err;
+  }
+  for (const entry of entries) {
+    const abs = join(root, entry.name);
+    if (entry.isDirectory()) yield* walk(abs);
+    else if (entry.isFile()) yield abs;
+  }
+}
+
+export async function buildHashes(opts) {
+  if (
+    !opts ||
+    typeof opts.packageRoot !== 'string' ||
+    typeof opts.packageName !== 'string' ||
+    typeof opts.packageVersion !== 'string' ||
+    typeof opts.assetPath !== 'string'
+  ) {
+    throw new Error(
+      'buildHashes requires { packageRoot, packageName, packageVersion, assetPath }.',
+    );
+  }
+  const { packageRoot, packageName, packageVersion, assetPath } = opts;
+  if (!isAbsolute(packageRoot)) {
+    throw new Error(
+      `packageRoot must be an absolute path; received: ${packageRoot}`,
+    );
+  }
+  const assetRoot = resolve(packageRoot, assetPath);
+  const files = {};
+  for await (const abs of walk(assetRoot)) {
+    const rel = toPosix(relative(assetRoot, abs));
+    if (NOISE.some((re) => re.test(rel))) continue;
+    const buf = await readFile(abs);
+    files[rel] = createHash('sha256').update(buf).digest('hex');
+  }
+  const sorted = Object.fromEntries(
+    Object.entries(files).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
+  );
+  const manifest = {
+    schemaVersion: 1,
+    package: { name: packageName, version: packageVersion },
+    generatedAt: new Date().toISOString(),
+    algorithm: 'sha256',
+    assetRoot: assetPath,
+    files: sorted,
+    previousVersions: {},
+  };
+  const distDir = resolve(packageRoot, 'dist');
+  await mkdir(distDir, { recursive: true });
+  const outPath = join(distDir, MANIFEST_FILENAME);
+  await writeFile(outPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8');
+  return { outPath, fileCount: Object.keys(sorted).length };
+}

package/scripts/claude-build-hashes.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Standalone CLI for `claude-build-hashes`.
+//
+// Reads the consumer's package.json at process.cwd() to extract the asset
+// path, then delegates to `buildHashes`. Consumers who want a different
+// manifest layout can skip this bin and ship a one-line
+// `scripts/build-hashes.mjs` that calls `buildHashes` directly with their
+// own parsed values.
+//
+// Convention: `pkg.claude?.assetPath` with a fallback of `'claude'`.
+// This convention is purely consumer-side — the library itself enforces
+// nothing about package.json shape.
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { buildHashes } from './buildHashes.mjs';
+
+try {
+  const packageRoot = process.cwd();
+  const pkg = JSON.parse(
+    await readFile(resolve(packageRoot, 'package.json'), 'utf-8'),
+  );
+  if (typeof pkg.name !== 'string' || typeof pkg.version !== 'string') {
+    throw new Error(
+      `${packageRoot}/package.json must define "name" and "version".`,
+    );
+  }
+  const assetPath =
+    typeof pkg.claude?.assetPath === 'string' && pkg.claude.assetPath.length > 0
+      ? pkg.claude.assetPath
+      : 'claude';
+  const { outPath, fileCount } = await buildHashes({
+    packageRoot,
+    packageName: pkg.name,
+    packageVersion: pkg.version,
+    assetPath,
+  });
+  console.log(`✓ claude-hashes.json written: ${fileCount} file(s) → ${outPath}`);
+} catch (err) {
+  console.error('❌ buildHashes failed:', err?.message ?? err);
+  process.exit(1);
+}

package/scripts/inject-version.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Semantic version regex (https://semver.org/)
+ * Matches: 0.0.1, 1.2.3, 1.0.0-beta.1, 2.0.0+build.123, etc.
+ */
+const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+/**
+ * Read and validate package.json version
+ */
+function readPackageVersion() {
+  const packageJsonPath = join(__dirname, '..', 'package.json');
+
+  try {
+    const content = readFileSync(packageJsonPath, 'utf-8');
+    const pkg = JSON.parse(content);
+
+    if (!pkg.version) {
+      console.error('❌ Error: No version field found in package.json');
+      process.exit(1);
+    }
+
+    if (!SEMVER_REGEX.test(pkg.version)) {
+      console.error(`❌ Error: Invalid semantic version "${pkg.version}" in package.json`);
+      console.error('   Expected format: MAJOR.MINOR.PATCH (e.g., 1.2.3, 1.0.0-beta.1)');
+      process.exit(1);
+    }
+
+    return pkg.version;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.error('❌ Error: package.json not found at', packageJsonPath);
+    } else if (error instanceof SyntaxError) {
+      console.error('❌ Error: Invalid JSON in package.json');
+    } else {
+      console.error('❌ Error reading package.json:', error.message);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Generate src/version.ts with current version
+ */
+function generateVersionFile(version) {
+  const versionFilePath = join(__dirname, '..', 'src', 'utils', 'version.ts');
+
+  try {
+    // Check if file exists and read current version
+    let currentVersion = null;
+    try {
+      const existingContent = readFileSync(versionFilePath, 'utf-8');
+      const match = existingContent.match(/VERSION = ['"]([^'"]+)['"]/);
+      if (match) {
+        currentVersion = match[1];
+      }
+    } catch {
+      // File doesn't exist yet, that's fine
+    }
+
+    if (currentVersion === version) {
+      console.log(`✓ Version file already up to date: ${version}`);
+      return false;
+    }
+
+    // Generate new version file
+    const content = `// Auto-generated by scripts/inject-version.js
+// DO NOT EDIT MANUALLY - This file is generated during build
+
+/**
+ * Current package version from package.json
+ * Automatically synchronized during build process
+ */
+export const VERSION = '${version}';
+`;
+
+    writeFileSync(versionFilePath, content, 'utf-8');
+
+    if (currentVersion) {
+      console.log(`✓ Version file updated: ${currentVersion} → ${version}`);
+    } else {
+      console.log(`✓ Version file created: ${version}`);
+    }
+    return true;
+  } catch (error) {
+    console.error('❌ Error generating version file:', error.message);
+    process.exit(1);
+  }
+}
+
+// Main execution
+try {
+  const version = readPackageVersion();
+  const updated = generateVersionFile(version);
+
+  if (!updated) {
+    console.log(`\n✅ Version is synchronized: ${version}`);
+  } else {
+    console.log(`\n✅ Version synchronization complete: ${version}`);
+  }
+} catch (error) {
+  console.error('❌ Unexpected error:', error.message);
+  process.exit(1);
+}

package/dist/cli.cjs

@@ -1,8 +0,0 @@
-'use strict';
-
-var cli = require('./core/cli.cjs');
-
-cli.run().catch((error) => {
-    console.error('Fatal error:', error.message);
-    process.exit(1);
-});

package/dist/cli.d.ts

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

package/dist/cli.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-import { run } from './core/cli.mjs';
-
-run().catch((error) => {
-    console.error('Fatal error:', error.message);
-    process.exit(1);
-});

package/dist/commands/add.cjs

@@ -1,80 +0,0 @@
-'use strict';
-
-var ink = require('ink');
-var React = require('react');
-var AddCommand = require('../components/add/AddCommand.cjs');
-var BulkAddView = require('../components/add/BulkAddView.cjs');
-var sync = require('../core/sync.cjs');
-
-async function runAddCommand(options, cwd) {
-    const workingDir = process.cwd();
-    if (options.pattern) {
-        try {
-            new RegExp(options.pattern);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`Invalid regex pattern "${options.pattern}": ${msg}`);
-        }
-        const { waitUntilExit } = ink.render(React.createElement(BulkAddView.BulkAddView, {
-            pattern: options.pattern,
-            cwd: workingDir,
-            local: options.local ?? false,
-            ref: options.ref,
-        }));
-        await waitUntilExit();
-        return;
-    }
-    if (!options.package) {
-        console.error('Error: either --package or --pattern must be provided');
-        console.error('  Usage: claude-assets-sync add -p <name>');
-        console.error('         claude-assets-sync add --pattern <regex>');
-        process.exit(1);
-    }
-    return new Promise((resolve, reject) => {
-        const { waitUntilExit } = ink.render(React.createElement(AddCommand.AddCommand, {
-            packageName: options.package,
-            local: options.local ?? false,
-            ref: options.ref,
-            onComplete: async (selection) => {
-                try {
-                    await performSync(selection, workingDir);
-                    resolve();
-                }
-                catch (error) {
-                    reject(error);
-                }
-            },
-            onError: (error) => {
-                reject(error);
-            },
-            onCancel: () => {
-                console.log('\nSync cancelled');
-                resolve();
-            },
-        }));
-        waitUntilExit().catch(reject);
-    });
-}
-async function performSync(selection, cwd) {
-    const exclusions = {
-        directories: [],
-        files: [],
-    };
-    for (const assetType of Object.keys(selection.excludedAssets)) {
-        for (const excludedPath of selection.excludedAssets[assetType]) {
-            exclusions.files.push(excludedPath);
-        }
-    }
-    await sync.syncPackage(selection.packageName, {
-        force: true,
-        dryRun: false,
-        local: selection.source === 'local',
-        ref: selection.ref,
-        flat: true,
-    }, cwd, exclusions.directories.length > 0 || exclusions.files.length > 0
-        ? exclusions
-        : undefined, undefined);
-}
-
-exports.runAddCommand = runAddCommand;