@slats/claude-assets-sync 0.3.0 → 0.3.2

package/README.md

@@ -4,9 +4,9 @@ Engine + dispatcher CLI that lets any npm package ship its own Claude Code docs
 
 ## Overview
 
-A consumer package declares `claude.assetPath` in `package.json` and runs `claude-build-hashes` during build to emit `dist/claude-hashes.json`. End users run `npx -p @slats/claude-assets-sync inject-claude-settings --package=<name>` and this engine resolves that single package's metadata via `createRequire`, compares the hash manifest against the target `.claude/`, and copies only what is out of date.
+A consumer package declares `claude.assetPath` in `package.json` and runs `claude-build-hashes` during build to emit `dist/claude-hashes.json`. End users run `npx -p @slats/claude-assets-sync inject-claude-settings --package=<name>` and this engine resolves each consumer's metadata, compares its hash manifest against the target `.claude/`, and copies only what is out of date.
 
-The library operates on exactly one consumer per invocation — the one named in `--package`. It never walks `node_modules` for siblings; it never enumerates workspaces.
+`--package` accepts a scoped name (`@scope/pkg`), an unscoped name (`pkg`), or a **scope alias** (`@scope` with no slash) that fans out to every installed `node_modules/@scope/*` package declaring `claude.assetPath`. Single-target resolution uses `createRequire`; scope-alias enumeration walks ancestor `node_modules/@<scope>/` directories from `cwd` upward and is isolated to `runCli/utils/resolveScopeAlias.ts`.
 
 No GitHub fetch, no `.sync-meta.json`, no migrations — the consumer's `dist/claude-hashes.json` is the single source of truth.
 
@@ -27,17 +27,19 @@ claude-build-hashes
 
 ### End-user invocation
 
+The engine is not shipped as a runtime dependency of consumers. Always invoke via `npx -p @slats/claude-assets-sync ...`; the package manager fetches and caches the engine on demand.
+
 ```bash
-# universal — every PM (pnpm strict / yarn-berry PnP included)
+# Single consumer:
 npx -p @slats/claude-assets-sync inject-claude-settings --package=@canard/schema-form --scope=user
 
-# simple — npm / yarn-classic only (relies on transitive bin hoist from the consumer's dependencies)
-npx inject-claude-settings --package=@canard/schema-form --scope=user
+# Scope alias — every installed @winglet/* that declares claude.assetPath:
+npx -p @slats/claude-assets-sync inject-claude-settings --package=@winglet --scope=user
 ```
 
 | Flag | Meaning |
 |---|---|
-| `--package <name>` | **Required.** Scoped npm name of a consumer that declares `claude.assetPath`. |
+| `--package <name>` | **Required.** Repeatable/comma-separable. Accepts `@scope/pkg`, `pkg`, or a scope alias `@scope` (fans out to every installed `node_modules/@scope/*` with `claude.assetPath`). |
 | `--scope=user` | `~/.claude` (applies globally). |
 | `--scope=project` | Nearest ancestor `.claude` directory, or `<cwd>/.claude` if none found. |
 | `--dry-run` | Print the copy / skip / warn plan, no writes. |
@@ -59,7 +61,7 @@ For `--scope=project` the target `.claude` directory is resolved by walking up f
     "build": "… && yarn build:hashes",
     "build:hashes": "claude-build-hashes"
   },
-  "dependencies": {
+  "devDependencies": {
     "@slats/claude-assets-sync": "workspace:^"
   },
   "files": ["dist", "docs", "README.md"],
@@ -67,7 +69,7 @@ For `--scope=project` the target `.claude` directory is resolved by walking up f
 }
 ```
 
-- `@slats/claude-assets-sync` MUST be in `dependencies`, not `devDependencies` — see Rationale below.
+- `@slats/claude-assets-sync` MUST be in `devDependencies` — the engine is a CLI-only tool and must not leak into end-user production installs. See Rationale below.
 - Do **not** add any `bin` field. The engine is the sole CLI surface; per-consumer bins would collide under `node_modules/.bin/`.
 - Do **not** expose `./bin/*` or `./docs/*` in `exports`. That would let consumer bundlers pull CLI code or the asset tree into app bundles.
 - Do **not** create a `bin/` or `scripts/` directory in the consumer.
@@ -82,10 +84,12 @@ yarn build
 
 Ship the resulting `dist/` (including `claude-hashes.json`) alongside `docs/` when you publish.
 
-### Rationale: `dependencies`, not `devDependencies`
+### Rationale: `devDependencies`, not `dependencies`
 
-- The monorepo build chain needs `.bin/claude-build-hashes` resolved, which requires the engine as a direct dep.
-- For end users on npm / yarn-classic, listing the engine in `dependencies` makes `inject-claude-settings` transitively hoisted into `node_modules/.bin/`, enabling the short invocation `npx inject-claude-settings --package=<THIS>`. Pnpm strict users do not get the transitive hoist and must use the universal form `npx -p @slats/claude-assets-sync inject-claude-settings --package=<THIS>`.
+- The engine is used at two moments only: (1) the consumer's own build, where `claude-build-hashes` produces `dist/claude-hashes.json`, and (2) the end user's one-off `inject-claude-settings` invocation. Neither is runtime behaviour of the consumer library.
+- Putting the engine in `dependencies` would force every downstream installer of the consumer to pull `commander`, `@inquirer/prompts`, and their transitive trees into their production `node_modules` — dead weight for anyone who never sets up Claude Code assets.
+- The workspace build chain still resolves `.bin/claude-build-hashes` from `devDependencies` at `yarn install` time; yarn workspaces link devDeps and deps identically for workspace-local builds.
+- End users never rely on a hoisted `inject-claude-settings` bin. The canonical invocation is `npx -p @slats/claude-assets-sync inject-claude-settings --package=<THIS>`, which fetches the engine on demand and caches it.
 - Bundle isolation is enforced by the import graph (`src/**` in the consumer never references the engine), not by dependency-type.
 
 ## Authoring `docs/claude/`

package/dist/claude-hashes.json

@@ -2,18 +2,18 @@
   "schemaVersion": 1,
   "package": {
     "name": "@slats/claude-assets-sync",
-    "version": "0.3.0"
+    "version": "0.3.2"
   },
-  "generatedAt": "2026-04-24T14:51:13.873Z",
+  "generatedAt": "2026-04-24T17:08:31.012Z",
   "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/SKILL.md": "4864a5a1aba0813fb64ad19111f3db4369df6cc025e485d03d17cdc9d245bce5",
+    "skills/claude-docs-asset-wiring/knowledge/claude-md-template.md": "b0274c5a37076a7e80bd7beccd739b10cc91ca5395fe425be25d9129206c684a",
     "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/gotchas.md": "70a6c75ea09816ec457615c060e6a87197bc5ed332a377452b3cacd974b44eee",
+    "skills/claude-docs-asset-wiring/knowledge/package-json-patches.md": "063469932191843a2f7f9156a513717947bcad584c4084a0c8300897683885e7",
+    "skills/claude-docs-asset-wiring/knowledge/reference-files.md": "1b5f76d262f47835c4d0150a48fa25dfc644609fd4ecad260273a4cab57e41a2",
     "skills/claude-docs-asset-wiring/knowledge/smoke-tests.md": "c90fc82d46bf4b55d794c2ce463b4c1e199d13d6b1161028486fb4bbbd6a60fe"
   },
   "previousVersions": {}

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

@@ -3,12 +3,14 @@
  *
  * The `inject-claude-settings` dispatcher parses `--package <name...>`
  * from argv and classifies each value:
- * - `@<scope>` — enumerate every workspace package under that scope
+ * - `@<scope>` — enumerate every installed `node_modules/@<scope>/*`
+ *   package that declares `claude.assetPath`
  * - `@<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`.
+ * `node_modules` siblings — that exception is isolated to
+ * `resolveScopeAlias.ts`.
  */
 export declare function runCli(argv?: readonly string[]): Promise<void>;

package/dist/commands/runCli/runCli.mjs

@@ -1,8 +1,9 @@
 import { Command } from 'commander';
 import { logger } from '../../utils/logger.mjs';
 import { VERSION } from '../../utils/version.mjs';
+import { renderOrFallback } from './utils/renderOrFallback.mjs';
 import { resolveTargets } from './utils/resolveTargets.mjs';
-import { runInject } from './utils/runInject.mjs';
+import { toConsumerPackages } from './utils/toConsumerPackages.mjs';
 
 async function runCli(argv = process.argv) {
     const cmd = new Command();
@@ -15,6 +16,7 @@ async function runCli(argv = process.argv) {
         .option('--dry-run', 'Preview without writing', false)
         .option('--force', 'Overwrite user modifications', false)
         .option('--root <path>', 'Override scope resolution cwd (default: cwd)')
+        .option('--json', 'Emit structured JSON output (forces non-interactive legacy logger path)', false)
         .action(async (flags) => {
         const targets = flags.package ?? [];
         if (targets.length === 0) {
@@ -27,7 +29,10 @@ async function runCli(argv = process.argv) {
             logger.warn(`no packages resolved from --package target(s): ${targets.join(', ')}`);
             return;
         }
-        await runInject(flags, metadataList);
+        const consumerPackages = await toConsumerPackages(metadataList);
+        const exitCode = await renderOrFallback(consumerPackages, flags, originCwd);
+        if (exitCode !== 0)
+            process.exit(exitCode);
     });
     try {
         await cmd.parseAsync([...argv]);

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

@@ -4,6 +4,7 @@ export interface DefaultFlags {
     force?: boolean;
     root?: string;
     package?: string[];
+    json?: boolean;
 }
 /**
  * Resolved consumer metadata passed to the injection pipeline.

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

@@ -0,0 +1,6 @@
+import type { ConsumerPackage, DefaultFlags } from '../type.js';
+interface RenderEnv {
+    readonly isTTY?: boolean;
+}
+export declare function renderOrFallback(targets: readonly ConsumerPackage[], flags: DefaultFlags, originCwd: string, env?: RenderEnv): Promise<number>;
+export {};

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

@@ -0,0 +1,12 @@
+import { renderPlain } from './renderPlain.mjs';
+
+async function renderOrFallback(targets, flags, originCwd, env = {}) {
+    const isTTY = env.isTTY ?? Boolean(process.stdout.isTTY);
+    if (flags.json || !isTTY) {
+        return renderPlain(targets, flags, originCwd);
+    }
+    const ui = (await import('../../../ui/index.mjs'));
+    return ui.renderInjectApp({ targets, flags, originCwd });
+}
+
+export { renderOrFallback };

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

@@ -0,0 +1,11 @@
+import type { ConsumerPackage, DefaultFlags } from '../type.js';
+/**
+ * Plain (picocolors) renderer for non-TTY / `--json` invocations.
+ *
+ * Composes the same `core/**` primitives that the Ink `useInjectSession`
+ * pipeline uses — no legacy `injectDocs` orchestrator in between.
+ * Missing `--scope` on non-TTY exits via `resolveScopeFlag` with code 2.
+ * Divergent/orphan files still respect `--force`: absence of `--force`
+ * returns 2; presence logs the list to stderr and proceeds.
+ */
+export declare function renderPlain(targets: readonly ConsumerPackage[], flags: DefaultFlags, originCwd: string): Promise<number>;

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

@@ -0,0 +1,89 @@
+import 'node:crypto';
+import 'node:fs/promises';
+import { readHashManifest, computeNamespacePrefixes } from '../../../core/hashManifest/hashManifest.mjs';
+import { applyAction } from '../../../core/injectDocs/utils/applyAction.mjs';
+import { summarize } from '../../../core/injectDocs/utils/summarize.mjs';
+import { buildPlan } from '../../../core/buildPlan/buildPlan.mjs';
+import { resolveScope } from '../../../core/scope/scope.mjs';
+import { asyncPool } from '../../../utils/asyncPool.mjs';
+import { logger } from '../../../utils/logger.mjs';
+import { resolveScopeFlag } from './resolveScopeFlag.mjs';
+
+async function renderPlain(targets, flags, originCwd) {
+    if (targets.length === 0)
+        return 0;
+    const scope = resolveScopeFlag(flags.scope);
+    const fatalOnError = targets.length === 1;
+    let failureCount = 0;
+    for (const target of targets) {
+        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.`);
+            continue;
+        }
+        logger.heading(`${target.name}@${target.version}`);
+        let exitCode;
+        try {
+            exitCode = await renderOneTarget(target, scope, flags, originCwd);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error(`${target.name}: ${msg}`);
+            exitCode = 1;
+        }
+        if (exitCode !== 0) {
+            if (fatalOnError)
+                return exitCode;
+            failureCount += 1;
+        }
+    }
+    return failureCount > 0 ? 1 : 0;
+}
+async function renderOneTarget(target, scope, flags, originCwd) {
+    const manifest = await readHashManifest(target.packageRoot);
+    const resolution = resolveScope(scope, originCwd);
+    const plan = await buildPlan({
+        sourceHashes: manifest.files,
+        targetRoot: resolution.targetRoot,
+        namespacePrefixes: computeNamespacePrefixes(manifest),
+        force: flags.force ?? false,
+    });
+    logger.info(`${target.name}@${target.version} → ${resolution.description}`);
+    printPlan(plan);
+    if (plan.requiresForce && !flags.force) {
+        logger.error('Re-run with --force to proceed, or inspect with --dry-run.');
+        return 2;
+    }
+    if (flags.force &&
+        plan.actions.some((a) => a.kind === 'warn-diverged' || a.kind === 'warn-orphan')) {
+        emitForceList(plan);
+    }
+    if (flags.dryRun) {
+        logger.warn('[DRY RUN] No files will be created, overwritten, or deleted.');
+        return 0;
+    }
+    await asyncPool(8, plan.actions, (action) => applyAction(action, target.assetRoot));
+    const report = summarize(plan, 0);
+    return report.exitCode;
+}
+function printPlan(plan) {
+    for (const action of plan.actions) {
+        if (action.kind === 'copy')
+            logger.file('create', action.relPath);
+        else if (action.kind === 'skip-uptodate')
+            logger.file('skip', `${action.relPath} (up-to-date)`);
+        else if (action.kind === 'warn-diverged')
+            logger.warn(`${action.relPath} — local differs from source (user edit or version change)`);
+        else if (action.kind === 'warn-orphan')
+            logger.warn(`${action.relPath} — present locally, absent in source`);
+        else if (action.kind === 'delete')
+            logger.file('update', `${action.relPath} (deleting)`);
+    }
+}
+function emitForceList(plan) {
+    const divergent = plan.actions.filter((action) => action.kind === 'warn-diverged' || action.kind === 'warn-orphan');
+    process.stderr.write(`[claude-assets-sync] --force overwriting ${divergent.length} file(s) in non-TTY mode:\n`);
+    for (const action of divergent)
+        process.stderr.write(`  ${action.relPath}\n`);
+}
+
+export { renderPlain };

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

@@ -1,27 +1,45 @@
 import { existsSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
-import { join, resolve, dirname } from 'node:path';
+import { resolve, join, dirname } from 'node:path';
 import { logger } from '../../../utils/logger.mjs';
 import { resolvePackage } from './resolvePackage.mjs';
 
 async function resolveScopeAlias(scope, rootCwd) {
-    const packagesRoot = findPackagesRoot(rootCwd);
-    if (!packagesRoot) {
-        logger.error(`cannot locate a monorepo root with a "packages/" directory starting from "${rootCwd}". Scope alias "@${scope}" requires a workspace root.`);
+    const expectedPrefix = `@${scope}/`;
+    const seen = new Set();
+    const matchedNames = [];
+    let cur = resolve(rootCwd);
+    while (true) {
+        const scopeDir = join(cur, 'node_modules', `@${scope}`);
+        await collectScopeDir(scopeDir, expectedPrefix, seen, matchedNames);
+        const parent = dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    if (matchedNames.length === 0) {
+        logger.error(`scope alias "@${scope}" matched no installed packages in any ancestor "node_modules/@${scope}/" walking up from ${rootCwd}.`);
         process.exit(2);
     }
-    const scopeDir = join(packagesRoot, 'packages', scope);
+    const resolved = [];
+    for (const name of matchedNames) {
+        const meta = await resolvePackage(name, { skipMissingAsset: true });
+        if (meta)
+            resolved.push(meta);
+    }
+    return resolved;
+}
+async function collectScopeDir(scopeDir, expectedPrefix, seen, matchedNames) {
     let entries;
     try {
         entries = await readdir(scopeDir);
     }
     catch {
-        logger.error(`scope alias "@${scope}" has no matching directory at ${scopeDir}.`);
-        process.exit(2);
+        return;
     }
-    const matchedNames = [];
-    const expectedPrefix = `@${scope}/`;
     for (const entry of entries) {
+        if (entry.startsWith('.'))
+            continue;
         const pkgJsonPath = join(scopeDir, entry, 'package.json');
         if (!existsSync(pkgJsonPath))
             continue;
@@ -35,33 +53,12 @@ async function resolveScopeAlias(scope, rootCwd) {
         }
         if (typeof parsed.name === 'string' &&
             parsed.name.startsWith(expectedPrefix) &&
-            parsed.name.length > expectedPrefix.length) {
+            parsed.name.length > expectedPrefix.length &&
+            !seen.has(parsed.name)) {
+            seen.add(parsed.name);
             matchedNames.push(parsed.name);
         }
     }
-    if (matchedNames.length === 0) {
-        logger.warn(`scope alias "@${scope}" matched no workspace packages under ${scopeDir}.`);
-        return [];
-    }
-    const resolved = [];
-    for (const name of matchedNames) {
-        const meta = await resolvePackage(name, { skipMissingAsset: true });
-        if (meta)
-            resolved.push(meta);
-    }
-    return resolved;
-}
-function findPackagesRoot(start) {
-    let cur = resolve(start);
-    while (true) {
-        if (existsSync(join(cur, 'package.json')) && existsSync(join(cur, 'packages'))) {
-            return cur;
-        }
-        const parent = dirname(cur);
-        if (parent === cur)
-            return null;
-        cur = parent;
-    }
 }
 
 export { resolveScopeAlias };

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

@@ -1,2 +1,10 @@
 import { type Scope } from '../../../core/index.js';
-export declare function resolveScopeFlag(flag: string | undefined): Promise<Scope>;
+/**
+ * Legacy (non-TTY / --json) scope resolver.
+ *
+ * The TTY Ink path owns its own scope picker via `ui/components/ScopePicker`.
+ * This helper runs only after `renderOrFallback` has chosen the legacy path,
+ * where prompting is not appropriate — either stdout is piped or the caller
+ * asked for structured `--json` output. Missing flag → exit 2.
+ */
+export declare function resolveScopeFlag(flag: string | undefined): Scope;

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

@@ -2,12 +2,9 @@ import 'node:crypto';
 import 'node:fs/promises';
 import 'node:path';
 import { logger } from '../../../utils/logger.mjs';
-import { isValidScope, isInteractive } from '../../../core/scope/scope.mjs';
-import { selectScopeAsync } from '../../../prompts/selectScope.mjs';
-import '@inquirer/prompts';
-import 'picocolors';
+import { isValidScope } from '../../../core/scope/scope.mjs';
 
-async function resolveScopeFlag(flag) {
+function resolveScopeFlag(flag) {
     if (flag) {
         if (!isValidScope(flag)) {
             logger.error(`Invalid --scope: ${flag}. Expected user | project.`);
@@ -15,12 +12,9 @@ async function resolveScopeFlag(flag) {
         }
         return flag;
     }
-    if (!isInteractive()) {
-        logger.error('--scope is required in non-interactive environments.');
-        logger.error('  Pass --scope=user | --scope=project.');
-        process.exit(2);
-    }
-    return selectScopeAsync();
+    logger.error('--scope is required in non-interactive environments.');
+    logger.error('  Pass --scope=user or --scope=project.');
+    process.exit(2);
 }
 
 export { resolveScopeFlag };

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

@@ -0,0 +1,9 @@
+import type { ConsumerPackage } from '../type.js';
+import type { ResolvedMetadata } from './resolvePackage.js';
+/**
+ * Convert dispatcher `ResolvedMetadata` into runtime `ConsumerPackage`.
+ * Resolves the asset root against `packageRoot` and probes for
+ * `dist/claude-hashes.json` presence so both the Ink and legacy paths
+ * can treat the target uniformly.
+ */
+export declare function toConsumerPackages(metadataList: readonly ResolvedMetadata[]): Promise<ConsumerPackage[]>;

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

@@ -0,0 +1,26 @@
+import { stat } from 'node:fs/promises';
+import { isAbsolute, resolve, join } from 'node:path';
+import { logger } from '../../../utils/logger.mjs';
+
+async function toConsumerPackages(metadataList) {
+    const result = [];
+    for (const metadata of metadataList) {
+        if (!isAbsolute(metadata.packageRoot)) {
+            logger.error(`packageRoot must be an absolute path; received: ${metadata.packageRoot}`);
+            process.exit(2);
+        }
+        const assetRoot = resolve(metadata.packageRoot, metadata.assetPath);
+        const hashesPath = join(metadata.packageRoot, 'dist', 'claude-hashes.json');
+        const hashesPresent = await stat(hashesPath).then(() => true, () => false);
+        result.push({
+            name: metadata.packageName,
+            version: metadata.packageVersion,
+            packageRoot: metadata.packageRoot,
+            assetRoot,
+            hashesPresent,
+        });
+    }
+    return result;
+}
+
+export { toConsumerPackages };

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
 export { hashContent, hashEquals, hashFile, type Sha256Hex, } from './hash/index.js';
 export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, readHashManifest, type HashManifest, } from './hashManifest/index.js';
-export { injectDocs, type InjectOptions, type InjectReport, } from './injectDocs/index.js';
+export { applyAction, summarize, type InjectReport, } from './injectDocs/index.js';
 export { buildPlan, type Action, type InjectPlan, type PlanInput, } from './buildPlan/index.js';
-export { findNearestDotClaudeAncestor, isInteractive, isValidScope, resolveScope, type Scope, type ScopeResolution, } from './scope/index.js';
+export { findNearestDotClaudeAncestor, isValidScope, resolveScope, type Scope, type ScopeResolution, } from './scope/index.js';

package/dist/core/injectDocs/index.d.ts

@@ -1,2 +1,3 @@
-export { injectDocs } from './injectDocs.js';
-export type { InjectOptions, InjectReport } from './type.js';
+export { applyAction } from './utils/applyAction.js';
+export { summarize } from './utils/summarize.js';
+export type { InjectReport } from './type.js';

package/dist/core/injectDocs/type.d.ts

@@ -1,22 +1,3 @@
-import type { InjectPlan } from '../buildPlan/index.js';
-import type { Scope } from '../scope/index.js';
-export interface InjectOptions {
-    packageName: string;
-    packageVersion: string;
-    packageRoot: string;
-    assetRoot: string;
-    scope: Scope;
-    dryRun: boolean;
-    force: boolean;
-    /**
-     * Origin directory used to resolve project/local scope targets. When set,
-     * `resolveScope` walks up from this path to find the nearest existing
-     * `.claude` ancestor. Defaults to `process.cwd()`.
-     */
-    originCwd?: string;
-    /** Called AFTER plan is built but BEFORE apply. Return false to abort. */
-    confirmForce?: (plan: InjectPlan) => Promise<boolean>;
-}
 export interface InjectReport {
     created: string[];
     updated: string[];

package/dist/core/scope/index.d.ts

@@ -1 +1 @@
-export { findNearestDotClaudeAncestor, isInteractive, isValidScope, resolveScope, type Scope, type ScopeResolution, } from './scope.js';
+export { findNearestDotClaudeAncestor, isValidScope, resolveScope, type Scope, type ScopeResolution, } from './scope.js';

package/dist/core/scope/scope.d.ts

@@ -13,4 +13,3 @@ export declare function isValidScope(value: unknown): value is Scope;
  */
 export declare function findNearestDotClaudeAncestor(start: string): string | null;
 export declare function resolveScope(scope: Scope, cwd?: string): ScopeResolution;
-export declare function isInteractive(): boolean;

package/dist/core/scope/scope.mjs

@@ -34,8 +34,5 @@ function resolveScope(scope, cwd = process.cwd()) {
             : `${base}/.claude (project)`,
     };
 }
-function isInteractive() {
-    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
-}
 
-export { findNearestDotClaudeAncestor, isInteractive, isValidScope, resolveScope };
+export { findNearestDotClaudeAncestor, isValidScope, resolveScope };

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { runCli } from './commands/index.js';
-export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, injectDocs, isInteractive, isValidScope, readHashManifest, resolveScope, type HashManifest, type InjectOptions, type InjectReport, type Scope, type ScopeResolution, } from './core/index.js';
+export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, isValidScope, readHashManifest, resolveScope, type HashManifest, type InjectReport, type Scope, type ScopeResolution, } from './core/index.js';
 export type { AssetType } from './utils/types.js';

package/dist/index.mjs

@@ -2,6 +2,6 @@ export { runCli } from './commands/runCli/runCli.mjs';
 import 'node:crypto';
 import 'node:fs/promises';
 export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, readHashManifest } from './core/hashManifest/hashManifest.mjs';
-export { injectDocs } from './core/injectDocs/injectDocs.mjs';
 import 'node:path';
-export { isInteractive, isValidScope, resolveScope } from './core/scope/scope.mjs';
+import 'picocolors';
+export { isValidScope, resolveScope } from './core/scope/scope.mjs';

package/dist/ui/InjectApp/InjectApp.d.ts

@@ -0,0 +1,2 @@
+import type { InjectAppProps } from './utils/type.js';
+export declare function InjectApp(props: InjectAppProps): React.ReactElement;

package/dist/ui/InjectApp/InjectApp.mjs

@@ -0,0 +1,82 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { useCallback } from 'react';
+import { VERSION } from '../../utils/version.mjs';
+import { Banner } from '../components/Banner.mjs';
+import { ConfirmForce } from '../components/ConfirmForce.mjs';
+import { ErrorPanel } from '../components/ErrorPanel.mjs';
+import { Footer } from '../components/Footer.mjs';
+import { ProgressBar } from '../components/ProgressBar.mjs';
+import { ScopePicker } from '../components/ScopePicker.mjs';
+import { Spinner } from '../components/Spinner.mjs';
+import { StepTracker } from '../components/StepTracker.mjs';
+import { Summary } from '../components/Summary.mjs';
+import { TargetCard } from '../components/TargetCard.mjs';
+import { useExitApp } from '../hooks/useExitApp.mjs';
+import { useInjectSession } from '../hooks/useInjectSession.mjs';
+import { usePhase } from '../hooks/usePhase.mjs';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+import { scopeLabel, etaSeconds } from './utils/eventSelectors.mjs';
+
+function InjectApp(props) {
+    const { targets, flags, originCwd, onExit } = props;
+    const [phase, dispatch] = usePhase({ kind: 'resolving', targets });
+    useInjectSession({ targets, flags, originCwd, dispatch });
+    const handleExit = useCallback((code) => {
+        onExit(code);
+    }, [onExit]);
+    useExitApp({
+        enabled: phase.kind === 'summary',
+        exitCode: phase.kind === 'summary' ? phase.exitCode : 0,
+        onExit: handleExit,
+        delayMs: 100,
+    });
+    useExitApp({
+        enabled: phase.kind === 'error',
+        exitCode: 1,
+        onExit: handleExit,
+        delayMs: 100,
+    });
+    return (jsxs(Box, { flexDirection: "column", children: [jsx(Banner, { version: VERSION, scope: scopeLabel(phase) }), jsx(Box, { marginTop: 1, children: jsx(StepTracker, { phase: phase, targetCount: targets.length, scope: scopeLabel(phase) }) }), jsx(Box, { flexDirection: "column", marginTop: 1, children: renderPhaseBody(phase) }), jsx(Footer, { phase: phase, version: VERSION })] }));
+}
+function renderPhaseBody(phase) {
+    switch (phase.kind) {
+        case 'booting':
+        case 'resolving':
+            return jsx(Spinner, { label: "resolving targets\u2026" });
+        case 'scope-select':
+            return jsx(ScopePicker, { onSelect: phase.pending });
+        case 'planning':
+            return (jsxs(Box, { flexDirection: "column", children: [jsx(Spinner, { label: "building plans\u2026" }), jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: [...phase.progress.values()].map((step) => (jsxs(Box, { children: [jsxs(Text, { color: step.status === 'done'
+                                        ? colors.success
+                                        : step.status === 'running'
+                                            ? colors.warn
+                                            : step.status === 'failed'
+                                                ? colors.danger
+                                                : colors.muted, bold: step.status === 'running', children: [step.status === 'done'
+                                            ? icons.check
+                                            : step.status === 'failed'
+                                                ? icons.cross
+                                                : step.status === 'running'
+                                                    ? icons.bulletActive
+                                                    : icons.bulletPending, ' '] }), jsx(Text, { children: step.packageName }), step.error ? (jsxs(Text, { color: colors.danger, dimColor: true, children: ['  ', "(", step.error, ")"] })) : null] }, step.packageName))) })] }));
+        case 'diff-review':
+            return (jsxs(Box, { flexDirection: "column", children: [phase.plans.map((tp, idx) => (jsx(TargetCard, { target: tp.target, plan: tp.plan, expanded: true, highlighted: idx === phase.focusedIndex }, tp.target.name))), jsx(Box, { marginTop: 1, children: jsxs(Text, { color: colors.muted, dimColor: true, children: ["Applying ", phase.plans.length, " plan(s)\u2026"] }) })] }));
+        case 'force-confirm':
+            return (jsx(ConfirmForce, { warnings: phase.warnings, onAnswer: phase.pending }));
+        case 'applying': {
+            const eta = etaSeconds(phase.progress.startedAt, phase.progress.done, phase.progress.total);
+            return (jsxs(Box, { flexDirection: "column", children: [jsx(ProgressBar, { done: phase.progress.done, total: phase.progress.total, etaSeconds: eta, label: phase.progress.current }), jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: phase.plans.map((tp) => (jsx(TargetCard, { target: tp.target, plan: tp.plan, expanded: false }, tp.target.name))) })] }));
+        }
+        case 'summary':
+            return (jsxs(Box, { flexDirection: "column", children: [phase.plans.map((tp) => (jsx(TargetCard, { target: tp.target, plan: tp.plan, expanded: false }, tp.target.name))), jsx(Summary, { reports: phase.reports, exitCode: phase.exitCode, dryRun: phase.dryRun })] }));
+        case 'error':
+            return jsx(ErrorPanel, { error: phase.error });
+        default: {
+            return null;
+        }
+    }
+}
+
+export { InjectApp };

package/dist/ui/InjectApp/index.d.ts

@@ -0,0 +1,2 @@
+export { renderInjectApp } from './utils/renderInjectApp.js';
+export { InjectApp } from './InjectApp.js';

package/dist/ui/InjectApp/utils/eventSelectors.d.ts

@@ -0,0 +1,5 @@
+import type { ConsumerPackage } from '../../../commands/runCli/type.js';
+import type { Phase } from '../../types/index.js';
+export declare function scopeLabel(phase: Phase): string | undefined;
+export declare function targetsOf(phase: Phase): readonly ConsumerPackage[];
+export declare function etaSeconds(startedAt: number, done: number, total: number, now?: number): number | undefined;