@slats/claude-assets-sync 0.3.0 → 0.3.1

package/dist/ui/hooks/useApplyStep.mjs

@@ -0,0 +1,30 @@
+import { applyAction } from '../../core/injectDocs/utils/applyAction.mjs';
+import { summarize } from '../../core/injectDocs/utils/summarize.mjs';
+import { asyncPool } from '../../utils/asyncPool.mjs';
+
+const CONCURRENCY = 8;
+async function applyAllPlans({ plans, dryRun, dispatch, }) {
+    const total = plans.reduce((acc, tp) => acc + tp.plan.actions.length, 0);
+    let done = 0;
+    dispatch({ type: 'apply-start', total });
+    if (dryRun) {
+        const reports = plans.map((tp) => summarize(tp.plan, 0));
+        dispatch({ type: 'done', reports, exitCode: 0, dryRun: true });
+        return { reports, exitCode: 0 };
+    }
+    const reports = [];
+    for (const tp of plans) {
+        await asyncPool(CONCURRENCY, tp.plan.actions, async (action) => {
+            await applyAction(action, tp.target.assetRoot);
+            done += 1;
+            dispatch({ type: 'apply-progress', done, current: action.relPath });
+        });
+        reports.push(summarize(tp.plan, 0));
+    }
+    const hasFailure = reports.some((r) => r.exitCode !== 0);
+    const exitCode = hasFailure ? 1 : 0;
+    dispatch({ type: 'done', reports, exitCode, dryRun: false });
+    return { reports, exitCode };
+}
+
+export { applyAllPlans };

package/dist/ui/hooks/useExitApp.d.ts

@@ -0,0 +1,8 @@
+interface UseExitAppOptions {
+    readonly enabled: boolean;
+    readonly exitCode: 0 | 1 | 2;
+    readonly onExit: (code: 0 | 1 | 2) => void;
+    readonly delayMs?: number;
+}
+export declare function useExitApp({ enabled, exitCode, onExit, delayMs, }: UseExitAppOptions): void;
+export {};

package/dist/ui/hooks/useExitApp.mjs

@@ -0,0 +1,19 @@
+import { useEffect } from 'react';
+import { useApp } from 'ink';
+
+function useExitApp({ enabled, exitCode, onExit, delayMs = 0, }) {
+    const { exit } = useApp();
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const handle = setTimeout(() => {
+            onExit(exitCode);
+            exit();
+        }, delayMs);
+        return () => {
+            clearTimeout(handle);
+        };
+    }, [enabled, exitCode, delayMs, exit, onExit]);
+}
+
+export { useExitApp };

package/dist/ui/hooks/useForceConfirmStep.d.ts

@@ -0,0 +1,9 @@
+import type { InjectEvent, TargetPlan, Warning } from '../types/index.js';
+interface RequestForceConfirmInput {
+    readonly plans: readonly TargetPlan[];
+    readonly warnings: readonly Warning[];
+    readonly force: boolean;
+    readonly dispatch: (event: InjectEvent) => void;
+}
+export declare function requestForceConfirm({ plans, warnings, force, dispatch, }: RequestForceConfirmInput): Promise<boolean>;
+export {};

package/dist/ui/hooks/useForceConfirmStep.mjs

@@ -0,0 +1,24 @@
+async function requestForceConfirm({ plans, warnings, force, dispatch, }) {
+    const hasWarnings = plans.some((p) => p.plan.requiresForce);
+    if (!hasWarnings)
+        return true;
+    if (!force) {
+        dispatch({
+            type: 'fail',
+            error: new Error('Re-run with --force to proceed, or inspect with --dry-run.'),
+        });
+        return false;
+    }
+    return new Promise((resolve) => {
+        dispatch({
+            type: 'force-confirm-required',
+            warnings,
+            pending: (ok) => {
+                dispatch({ type: 'force-answer', ok });
+                resolve(ok);
+            },
+        });
+    });
+}
+
+export { requestForceConfirm };

package/dist/ui/hooks/useInjectSession.d.ts

@@ -0,0 +1,10 @@
+import type { ConsumerPackage, DefaultFlags } from '../../commands/runCli/type.js';
+import type { InjectEvent } from '../types/index.js';
+interface UseInjectSessionOptions {
+    readonly targets: readonly ConsumerPackage[];
+    readonly flags: DefaultFlags;
+    readonly originCwd: string;
+    readonly dispatch: (event: InjectEvent) => void;
+}
+export declare function useInjectSession({ targets, flags, originCwd, dispatch, }: UseInjectSessionOptions): void;
+export {};

package/dist/ui/hooks/useInjectSession.mjs

@@ -0,0 +1,63 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { applyAllPlans } from './useApplyStep.mjs';
+import { requestForceConfirm } from './useForceConfirmStep.mjs';
+import { usePlanStep } from './usePlanStep.mjs';
+import { useResolveStep } from './useResolveStep.mjs';
+
+function useInjectSession({ targets, flags, originCwd, dispatch, }) {
+    const [scope, setScope] = useState(null);
+    const [plansReady, setPlansReady] = useState(null);
+    const pipelineStarted = useRef(false);
+    const onScopeResolved = useCallback((resolved) => {
+        setScope(resolved);
+    }, []);
+    const onPlansReady = useCallback((plans, warnings) => {
+        setPlansReady({ plans, warnings });
+    }, []);
+    useResolveStep({ targets, flags, dispatch, onScopeResolved });
+    usePlanStep({
+        targets,
+        scope,
+        originCwd,
+        force: Boolean(flags.force),
+        dispatch,
+        onPlansReady,
+    });
+    useEffect(() => {
+        if (!plansReady || pipelineStarted.current)
+            return;
+        pipelineStarted.current = true;
+        (async () => {
+            const { plans, warnings } = plansReady;
+            if (plans.length === 0) {
+                dispatch({
+                    type: 'done',
+                    reports: [],
+                    exitCode: 2,
+                    dryRun: Boolean(flags.dryRun),
+                });
+                return;
+            }
+            const ok = await requestForceConfirm({
+                plans,
+                warnings,
+                force: Boolean(flags.force),
+                dispatch,
+            });
+            if (!ok)
+                return;
+            await applyAllPlans({
+                plans,
+                dryRun: Boolean(flags.dryRun),
+                dispatch,
+            });
+        })().catch((error) => {
+            dispatch({
+                type: 'fail',
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        });
+    }, [plansReady, flags.force, flags.dryRun, dispatch]);
+}
+
+export { useInjectSession };

package/dist/ui/hooks/useInterval.d.ts

@@ -0,0 +1 @@
+export declare function useInterval(callback: () => void, delayMs: number | null): void;

package/dist/ui/hooks/usePhase.d.ts

@@ -0,0 +1,2 @@
+import type { InjectEvent, Phase } from '../types/index.js';
+export declare function usePhase(initial: Phase): [Phase, (event: InjectEvent) => void];

package/dist/ui/hooks/usePhase.mjs

@@ -0,0 +1,9 @@
+import { useReducer } from 'react';
+import { phaseReducer } from '../InjectApp/utils/phaseReducer.mjs';
+
+function usePhase(initial) {
+    const [phase, dispatch] = useReducer(phaseReducer, initial);
+    return [phase, dispatch];
+}
+
+export { usePhase };

package/dist/ui/hooks/usePlanStep.d.ts

@@ -0,0 +1,13 @@
+import type { ConsumerPackage } from '../../commands/runCli/type.js';
+import { type Scope } from '../../core/index.js';
+import type { InjectEvent, TargetPlan, Warning } from '../types/index.js';
+interface UsePlanStepOptions {
+    readonly targets: readonly ConsumerPackage[];
+    readonly scope: Scope | null;
+    readonly originCwd: string;
+    readonly force: boolean;
+    readonly dispatch: (event: InjectEvent) => void;
+    readonly onPlansReady: (plans: readonly TargetPlan[], warnings: readonly Warning[]) => void;
+}
+export declare function usePlanStep({ targets, scope, originCwd, force, dispatch, onPlansReady, }: UsePlanStepOptions): void;
+export {};

package/dist/ui/hooks/usePlanStep.mjs

@@ -0,0 +1,94 @@
+import { useRef, useEffect } from 'react';
+import 'node:crypto';
+import 'node:fs/promises';
+import { readHashManifest, computeNamespacePrefixes } from '../../core/hashManifest/hashManifest.mjs';
+import 'node:path';
+import 'picocolors';
+import { buildPlan } from '../../core/buildPlan/buildPlan.mjs';
+import { resolveScope } from '../../core/scope/scope.mjs';
+
+function usePlanStep({ targets, scope, originCwd, force, dispatch, onPlansReady, }) {
+    const startedRef = useRef(false);
+    useEffect(() => {
+        if (!scope || startedRef.current)
+            return;
+        startedRef.current = true;
+        let cancelled = false;
+        (async () => {
+            const results = [];
+            const warnings = [];
+            for (const target of targets) {
+                if (cancelled)
+                    return;
+                dispatch({
+                    type: 'plan-step',
+                    step: { packageName: target.name, status: 'running' },
+                });
+                try {
+                    if (!target.hashesPresent) {
+                        dispatch({
+                            type: 'plan-step',
+                            step: {
+                                packageName: target.name,
+                                status: 'failed',
+                                error: 'dist/claude-hashes.json missing',
+                            },
+                        });
+                        continue;
+                    }
+                    const manifest = await readHashManifest(target.packageRoot);
+                    const scopeResolution = resolveScope(scope, originCwd);
+                    const plan = await buildPlan({
+                        sourceHashes: manifest.files,
+                        targetRoot: scopeResolution.targetRoot,
+                        namespacePrefixes: computeNamespacePrefixes(manifest),
+                        force,
+                    });
+                    results.push({ target, scope: scopeResolution, plan });
+                    for (const action of plan.actions) {
+                        if (action.kind === 'warn-diverged' || action.kind === 'warn-orphan') {
+                            warnings.push({
+                                packageName: target.name,
+                                kind: action.kind,
+                                relPath: action.relPath,
+                                description: action.kind === 'warn-diverged'
+                                    ? 'local differs from source (user edit or version change)'
+                                    : 'exists locally but not in manifest',
+                            });
+                        }
+                    }
+                    dispatch({
+                        type: 'plan-step',
+                        step: { packageName: target.name, status: 'done' },
+                    });
+                }
+                catch (error) {
+                    dispatch({
+                        type: 'plan-step',
+                        step: {
+                            packageName: target.name,
+                            status: 'failed',
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                }
+            }
+            if (cancelled)
+                return;
+            dispatch({ type: 'plans-ready', plans: results });
+            onPlansReady(results, warnings);
+        })().catch((error) => {
+            if (!cancelled) {
+                dispatch({
+                    type: 'fail',
+                    error: error instanceof Error ? error : new Error(String(error)),
+                });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [targets, scope, originCwd, force, dispatch, onPlansReady]);
+}
+
+export { usePlanStep };

package/dist/ui/hooks/useResolveStep.d.ts

@@ -0,0 +1,18 @@
+import type { ConsumerPackage } from '../../commands/runCli/type.js';
+import type { Scope } from '../../core/index.js';
+import type { InjectEvent } from '../types/index.js';
+interface UseResolveStepOptions {
+    readonly targets: readonly ConsumerPackage[];
+    readonly flags: {
+        readonly scope?: string;
+    };
+    readonly dispatch: (event: InjectEvent) => void;
+    readonly onScopeResolved: (scope: Scope) => void;
+}
+/**
+ * Ink path is guaranteed TTY by `renderOrFallback`, so interactive
+ * scope selection is always safe. Non-TTY invocations go through
+ * `renderPlain` + `resolveScopeFlag` which exits 2 on missing scope.
+ */
+export declare function useResolveStep({ targets, flags, dispatch, onScopeResolved, }: UseResolveStepOptions): void;
+export {};

package/dist/ui/hooks/useResolveStep.mjs

@@ -0,0 +1,21 @@
+import { useEffect } from 'react';
+
+function useResolveStep({ targets, flags, dispatch, onScopeResolved, }) {
+    useEffect(() => {
+        if (flags.scope === 'user' || flags.scope === 'project') {
+            const resolved = flags.scope;
+            dispatch({ type: 'scope-selected', scope: resolved });
+            dispatch({ type: 'planning-started', targets, scope: resolved });
+            onScopeResolved(resolved);
+            return;
+        }
+        const pending = (scope) => {
+            dispatch({ type: 'scope-selected', scope });
+            dispatch({ type: 'planning-started', targets, scope });
+            onScopeResolved(scope);
+        };
+        dispatch({ type: 'scope-needed', pending });
+    }, [targets, flags.scope, dispatch, onScopeResolved]);
+}
+
+export { useResolveStep };

package/dist/ui/hooks/useTerminalWidth.d.ts

@@ -0,0 +1 @@
+export declare function useTerminalWidth(): number;

package/dist/ui/index.d.ts

@@ -0,0 +1,2 @@
+export { renderInjectApp } from './InjectApp/index.js';
+export type { Phase, InjectEvent, RenderInput, TargetPlan, Warning, ApplyProgress, PlanStepState, } from './types/index.js';

package/dist/ui/index.mjs

@@ -0,0 +1,16 @@
+import { renderInjectApp } from './InjectApp/utils/renderInjectApp.mjs';
+import 'react/jsx-runtime';
+import 'react';
+import 'ink';
+import 'ink-select-input';
+import 'ink-spinner';
+import 'node:fs/promises';
+import 'node:path';
+import 'picocolors';
+import 'node:crypto';
+import 'node:os';
+import 'node:fs';
+
+
+
+export { renderInjectApp };

package/dist/ui/theme/colors.d.ts

@@ -0,0 +1,12 @@
+export declare const colors: {
+    readonly primary: "cyan";
+    readonly success: "green";
+    readonly warn: "yellow";
+    readonly danger: "red";
+    readonly muted: "gray";
+    readonly accent: "magenta";
+    readonly info: "blue";
+    readonly dim: "gray";
+};
+export declare const gradientStops: readonly ["#22d3ee", "#a78bfa", "#f59e0b"];
+export type ColorName = (typeof colors)[keyof typeof colors];

package/dist/ui/theme/colors.mjs

@@ -0,0 +1,9 @@
+const colors = {
+    primary: 'cyan',
+    success: 'green',
+    warn: 'yellow',
+    danger: 'red',
+    muted: 'gray',
+    accent: 'magenta'};
+
+export { colors };

package/dist/ui/theme/icons.d.ts

@@ -0,0 +1,29 @@
+export declare const icons: {
+    readonly bulletDone: "●";
+    readonly bulletActive: "◐";
+    readonly bulletPending: "○";
+    readonly triangleRight: "▸";
+    readonly check: "✓";
+    readonly cross: "✗";
+    readonly warning: "⚠";
+    readonly question: "?";
+    readonly plus: "+";
+    readonly equals: "=";
+    readonly minus: "−";
+    readonly tilde: "~";
+    readonly blockFull: "█";
+    readonly blockEmpty: "░";
+    readonly dash: "─";
+    readonly divider: "───";
+    readonly boxTopLeft: "╭";
+    readonly boxTopRight: "╮";
+    readonly boxBottomLeft: "╰";
+    readonly boxBottomRight: "╯";
+    readonly boxHorizontal: "─";
+    readonly boxVertical: "│";
+    readonly boxDoubleTopLeft: "┌";
+    readonly boxDoubleTopRight: "┐";
+    readonly boxDoubleBottomLeft: "└";
+    readonly boxDoubleBottomRight: "┘";
+};
+export type IconName = keyof typeof icons;

package/dist/ui/theme/icons.mjs

@@ -0,0 +1,17 @@
+const icons = {
+    bulletDone: '●',
+    bulletActive: '◐',
+    bulletPending: '○',
+    triangleRight: '▸',
+    check: '✓',
+    cross: '✗',
+    warning: '⚠',
+    question: '?',
+    plus: '+',
+    equals: '=',
+    minus: '−',
+    blockFull: '█',
+    blockEmpty: '░',
+    divider: '───'};
+
+export { icons };

package/dist/ui/theme/layout.d.ts

@@ -0,0 +1,20 @@
+export declare const spacing: {
+    readonly xs: 0;
+    readonly sm: 1;
+    readonly md: 2;
+    readonly lg: 3;
+    readonly xl: 4;
+};
+export declare const widths: {
+    readonly statusBadge: 10;
+    readonly pathColumn: 60;
+    readonly progressBarDefault: 28;
+    readonly targetCardCount: 18;
+    readonly minTerminalWidth: 60;
+    readonly idealTerminalWidth: 120;
+};
+export declare const limits: {
+    readonly maxWarningsBeforeCollapse: 10;
+    readonly maxPlanRowsBeforeTruncate: 40;
+    readonly planTruncatedReveal: 15;
+};

package/dist/ui/theme/layout.mjs

@@ -0,0 +1,9 @@
+const widths = {
+    progressBarDefault: 28};
+const limits = {
+    maxWarningsBeforeCollapse: 10,
+    maxPlanRowsBeforeTruncate: 40,
+    planTruncatedReveal: 15,
+};
+
+export { limits, widths };

package/dist/ui/types/event.d.ts

@@ -0,0 +1,45 @@
+import type { ConsumerPackage } from '../../commands/runCli/type.js';
+import type { InjectReport, Scope } from '../../core/index.js';
+import type { PlanStepState, TargetPlan, Warning } from './target.js';
+export type InjectEvent = {
+    readonly type: 'scope-needed';
+    readonly pending: (scope: Scope) => void;
+} | {
+    readonly type: 'scope-selected';
+    readonly scope: Scope;
+} | {
+    readonly type: 'planning-started';
+    readonly targets: readonly ConsumerPackage[];
+    readonly scope: Scope;
+} | {
+    readonly type: 'plan-step';
+    readonly step: PlanStepState;
+} | {
+    readonly type: 'plans-ready';
+    readonly plans: readonly TargetPlan[];
+} | {
+    readonly type: 'force-confirm-required';
+    readonly warnings: readonly Warning[];
+    readonly pending: (ok: boolean) => void;
+} | {
+    readonly type: 'force-answer';
+    readonly ok: boolean;
+} | {
+    readonly type: 'apply-start';
+    readonly total: number;
+} | {
+    readonly type: 'apply-progress';
+    readonly done: number;
+    readonly current?: string;
+} | {
+    readonly type: 'done';
+    readonly reports: readonly InjectReport[];
+    readonly exitCode: 0 | 1 | 2;
+    readonly dryRun: boolean;
+} | {
+    readonly type: 'fail';
+    readonly error: Error;
+} | {
+    readonly type: 'focus-target';
+    readonly index: number;
+};

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

@@ -0,0 +1,4 @@
+export type { Phase } from './phase.js';
+export type { InjectEvent } from './event.js';
+export type { RenderInput } from './render.js';
+export type { ApplyProgress, PlanStepState, TargetPlan, Warning, } from './target.js';

package/dist/ui/types/phase.d.ts

@@ -0,0 +1,44 @@
+import type { ConsumerPackage } from '../../commands/runCli/type.js';
+import type { InjectReport, Scope } from '../../core/index.js';
+import type { ApplyProgress, PlanStepState, TargetPlan, Warning } from './target.js';
+export type Phase = {
+    readonly kind: 'booting';
+} | {
+    readonly kind: 'resolving';
+    readonly targets: readonly ConsumerPackage[];
+} | {
+    readonly kind: 'scope-select';
+    readonly targets: readonly ConsumerPackage[];
+    readonly pending: (scope: Scope) => void;
+} | {
+    readonly kind: 'planning';
+    readonly targets: readonly ConsumerPackage[];
+    readonly scope: Scope;
+    readonly progress: ReadonlyMap<string, PlanStepState>;
+} | {
+    readonly kind: 'diff-review';
+    readonly plans: readonly TargetPlan[];
+    readonly focusedIndex: number;
+    readonly scope: Scope;
+} | {
+    readonly kind: 'force-confirm';
+    readonly plans: readonly TargetPlan[];
+    readonly warnings: readonly Warning[];
+    readonly pending: (ok: boolean) => void;
+    readonly scope: Scope;
+} | {
+    readonly kind: 'applying';
+    readonly plans: readonly TargetPlan[];
+    readonly progress: ApplyProgress;
+    readonly scope: Scope;
+} | {
+    readonly kind: 'summary';
+    readonly reports: readonly InjectReport[];
+    readonly plans: readonly TargetPlan[];
+    readonly exitCode: 0 | 1 | 2;
+    readonly scope: Scope;
+    readonly dryRun: boolean;
+} | {
+    readonly kind: 'error';
+    readonly error: Error;
+};

package/dist/ui/types/render.d.ts

@@ -0,0 +1,6 @@
+import type { ConsumerPackage, DefaultFlags } from '../../commands/runCli/type.js';
+export interface RenderInput {
+    readonly targets: readonly ConsumerPackage[];
+    readonly flags: DefaultFlags;
+    readonly originCwd: string;
+}

package/dist/ui/types/target.d.ts

@@ -0,0 +1,25 @@
+import type { InjectPlan } from '../../core/buildPlan/index.js';
+import type { ScopeResolution } from '../../core/index.js';
+import type { ConsumerPackage } from '../../commands/runCli/type.js';
+export interface PlanStepState {
+    readonly packageName: string;
+    readonly status: 'pending' | 'running' | 'done' | 'failed';
+    readonly error?: string;
+}
+export interface TargetPlan {
+    readonly target: ConsumerPackage;
+    readonly scope: ScopeResolution;
+    readonly plan: InjectPlan;
+}
+export interface Warning {
+    readonly packageName: string;
+    readonly kind: 'warn-diverged' | 'warn-orphan';
+    readonly relPath: string;
+    readonly description: string;
+}
+export interface ApplyProgress {
+    readonly total: number;
+    readonly done: number;
+    readonly current?: string;
+    readonly startedAt: number;
+}

package/dist/utils/version.d.ts

@@ -2,4 +2,4 @@
  * Current package version from package.json
  * Automatically synchronized during build process
  */
-export declare const VERSION = "0.3.0";
+export declare const VERSION = "0.3.1";

package/dist/utils/version.mjs

@@ -1,3 +1,3 @@
-const VERSION = '0.3.0';
+const VERSION = '0.3.1';
 
 export { VERSION };

package/docs/claude/skills/claude-docs-asset-wiring/SKILL.md

@@ -78,7 +78,7 @@ See `knowledge/package-json-patches.md` for the complete patch list:
 - `scripts.build` — ensure the chain ends with `&& yarn build:hashes`.
 - `scripts.build:hashes` — set to `claude-build-hashes` (the engine's bin).
 - `scripts.prepublishOnly` — `yarn build` if not already present.
-- `dependencies."@slats/claude-assets-sync"` — add (NOT `devDependencies`, NOT `peerDependencies`).
+- `devDependencies."@slats/claude-assets-sync"` — add (NOT `dependencies`, NOT `peerDependencies`). The engine is CLI-only and must not leak into end-user production installs.
 - `files` — ensure `"dist"`, `"docs"`, `"README.md"` are listed. Never include `"bin"` or `"scripts"`.
 
 Do NOT add any `bin` entry. Do NOT add `./bin/*` or `./docs/*` to `exports`.