@slats/claude-assets-sync 0.1.4 → 0.3.0

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

@@ -0,0 +1,69 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var promises = require('node:fs/promises');
+var node_path = require('node:path');
+var logger = require('../../../utils/logger.cjs');
+var resolvePackage = require('./resolvePackage.cjs');
+
+async function resolveScopeAlias(scope, rootCwd) {
+    const packagesRoot = findPackagesRoot(rootCwd);
+    if (!packagesRoot) {
+        logger.logger.error(`cannot locate a monorepo root with a "packages/" directory starting from "${rootCwd}". Scope alias "@${scope}" requires a workspace root.`);
+        process.exit(2);
+    }
+    const scopeDir = node_path.join(packagesRoot, 'packages', scope);
+    let entries;
+    try {
+        entries = await promises.readdir(scopeDir);
+    }
+    catch {
+        logger.logger.error(`scope alias "@${scope}" has no matching directory at ${scopeDir}.`);
+        process.exit(2);
+    }
+    const matchedNames = [];
+    const expectedPrefix = `@${scope}/`;
+    for (const entry of entries) {
+        const pkgJsonPath = node_path.join(scopeDir, entry, 'package.json');
+        if (!node_fs.existsSync(pkgJsonPath))
+            continue;
+        let parsed;
+        try {
+            const raw = await promises.readFile(pkgJsonPath, 'utf-8');
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed.name === 'string' &&
+            parsed.name.startsWith(expectedPrefix) &&
+            parsed.name.length > expectedPrefix.length) {
+            matchedNames.push(parsed.name);
+        }
+    }
+    if (matchedNames.length === 0) {
+        logger.logger.warn(`scope alias "@${scope}" matched no workspace packages under ${scopeDir}.`);
+        return [];
+    }
+    const resolved = [];
+    for (const name of matchedNames) {
+        const meta = await resolvePackage.resolvePackage(name, { skipMissingAsset: true });
+        if (meta)
+            resolved.push(meta);
+    }
+    return resolved;
+}
+function findPackagesRoot(start) {
+    let cur = node_path.resolve(start);
+    while (true) {
+        if (node_fs.existsSync(node_path.join(cur, 'package.json')) && node_fs.existsSync(node_path.join(cur, 'packages'))) {
+            return cur;
+        }
+        const parent = node_path.dirname(cur);
+        if (parent === cur)
+            return null;
+        cur = parent;
+    }
+}
+
+exports.resolveScopeAlias = resolveScopeAlias;

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

@@ -0,0 +1,2 @@
+import { type ResolvedMetadata } from './resolvePackage.js';
+export declare function resolveScopeAlias(scope: string, rootCwd: string): Promise<ResolvedMetadata[]>;

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

@@ -0,0 +1,67 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, resolve, 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.`);
+        process.exit(2);
+    }
+    const scopeDir = join(packagesRoot, 'packages', scope);
+    let entries;
+    try {
+        entries = await readdir(scopeDir);
+    }
+    catch {
+        logger.error(`scope alias "@${scope}" has no matching directory at ${scopeDir}.`);
+        process.exit(2);
+    }
+    const matchedNames = [];
+    const expectedPrefix = `@${scope}/`;
+    for (const entry of entries) {
+        const pkgJsonPath = join(scopeDir, entry, 'package.json');
+        if (!existsSync(pkgJsonPath))
+            continue;
+        let parsed;
+        try {
+            const raw = await readFile(pkgJsonPath, 'utf-8');
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed.name === 'string' &&
+            parsed.name.startsWith(expectedPrefix) &&
+            parsed.name.length > expectedPrefix.length) {
+            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.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+require('node:crypto');
+require('node:fs/promises');
+require('node:path');
+var logger = require('../../../utils/logger.cjs');
+var scope = require('../../../core/scope/scope.cjs');
+var selectScope = require('../../../prompts/selectScope.cjs');
+require('@inquirer/prompts');
+require('picocolors');
+
+async function resolveScopeFlag(flag) {
+    if (flag) {
+        if (!scope.isValidScope(flag)) {
+            logger.logger.error(`Invalid --scope: ${flag}. Expected user | project.`);
+            process.exit(2);
+        }
+        return flag;
+    }
+    if (!scope.isInteractive()) {
+        logger.logger.error('--scope is required in non-interactive environments.');
+        logger.logger.error('  Pass --scope=user | --scope=project.');
+        process.exit(2);
+    }
+    return selectScope.selectScopeAsync();
+}
+
+exports.resolveScopeFlag = resolveScopeFlag;

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

@@ -0,0 +1,2 @@
+import { type Scope } from '../../../core/index.js';
+export declare function resolveScopeFlag(flag: string | undefined): Promise<Scope>;

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

@@ -0,0 +1,26 @@
+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';
+
+async function resolveScopeFlag(flag) {
+    if (flag) {
+        if (!isValidScope(flag)) {
+            logger.error(`Invalid --scope: ${flag}. Expected user | project.`);
+            process.exit(2);
+        }
+        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();
+}
+
+export { resolveScopeFlag };

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

@@ -0,0 +1,40 @@
+'use strict';
+
+var logger = require('../../../utils/logger.cjs');
+var classifyTarget = require('./classifyTarget.cjs');
+var resolvePackage = require('./resolvePackage.cjs');
+var resolveScopeAlias = require('./resolveScopeAlias.cjs');
+
+async function resolveTargets(targets, rootCwd) {
+    if (targets.length === 0)
+        return [];
+    const isSingleTarget = targets.length === 1;
+    const seen = new Set();
+    const results = [];
+    for (const target of targets) {
+        const classification = classifyTarget.classifyTarget(target);
+        if (classification.kind === 'invalid') {
+            logger.logger.error(classification.reason);
+            process.exit(2);
+        }
+        let candidates;
+        if (classification.kind === 'scope') {
+            candidates = await resolveScopeAlias.resolveScopeAlias(classification.scope, rootCwd);
+        }
+        else {
+            const meta = await resolvePackage.resolvePackage(classification.name, {
+                skipMissingAsset: !isSingleTarget,
+            });
+            candidates = meta ? [meta] : [];
+        }
+        for (const meta of candidates) {
+            if (!seen.has(meta.packageName)) {
+                seen.add(meta.packageName);
+                results.push(meta);
+            }
+        }
+    }
+    return results;
+}
+
+exports.resolveTargets = resolveTargets;

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

@@ -0,0 +1,15 @@
+import { type ResolvedMetadata } from './resolvePackage.js';
+/**
+ * Classify each `--package` value, resolve them all, and dedupe the
+ * result by `packageName`.
+ *
+ * - `@<scope>` values enumerate through `resolveScopeAlias` (soft skip
+ *   when a workspace package lacks `claude.assetPath`).
+ * - `@<scope>/<name>` and `<name>` values go through `resolvePackage`.
+ *   When there is a single `--package` value, the call is strict
+ *   (asset-missing → exit 2); otherwise asset-missing is a soft skip
+ *   so the rest of the batch can proceed.
+ *
+ * Invalid `--package` values exit with code 2 before any filesystem IO.
+ */
+export declare function resolveTargets(targets: readonly string[], rootCwd: string): Promise<ResolvedMetadata[]>;

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

@@ -0,0 +1,38 @@
+import { logger } from '../../../utils/logger.mjs';
+import { classifyTarget } from './classifyTarget.mjs';
+import { resolvePackage } from './resolvePackage.mjs';
+import { resolveScopeAlias } from './resolveScopeAlias.mjs';
+
+async function resolveTargets(targets, rootCwd) {
+    if (targets.length === 0)
+        return [];
+    const isSingleTarget = targets.length === 1;
+    const seen = new Set();
+    const results = [];
+    for (const target of targets) {
+        const classification = classifyTarget(target);
+        if (classification.kind === 'invalid') {
+            logger.error(classification.reason);
+            process.exit(2);
+        }
+        let candidates;
+        if (classification.kind === 'scope') {
+            candidates = await resolveScopeAlias(classification.scope, rootCwd);
+        }
+        else {
+            const meta = await resolvePackage(classification.name, {
+                skipMissingAsset: !isSingleTarget,
+            });
+            candidates = meta ? [meta] : [];
+        }
+        for (const meta of candidates) {
+            if (!seen.has(meta.packageName)) {
+                seen.add(meta.packageName);
+                results.push(meta);
+            }
+        }
+    }
+    return results;
+}
+
+export { resolveTargets };

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

@@ -0,0 +1,52 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var node_path = require('node:path');
+var logger = require('../../../utils/logger.cjs');
+var injectOne = require('./injectOne.cjs');
+var resolveScopeFlag = require('./resolveScopeFlag.cjs');
+
+async function runInject(flags, metadataList) {
+    if (metadataList.length === 0)
+        return;
+    for (const metadata of metadataList) {
+        if (!node_path.isAbsolute(metadata.packageRoot)) {
+            logger.logger.error(`packageRoot must be an absolute path; received: ${metadata.packageRoot}`);
+            process.exit(2);
+        }
+    }
+    const originCwd = flags.root ?? process.cwd();
+    const scope = await resolveScopeFlag.resolveScopeFlag(flags.scope);
+    const fatalOnError = metadataList.length === 1;
+    let failureCount = 0;
+    for (const metadata of metadataList) {
+        const assetRoot = node_path.resolve(metadata.packageRoot, metadata.assetPath);
+        const hashesPath = node_path.join(metadata.packageRoot, 'dist', 'claude-hashes.json');
+        const hashesPresent = await promises.stat(hashesPath).then(() => true, () => false);
+        const target = {
+            name: metadata.packageName,
+            version: metadata.packageVersion,
+            packageRoot: metadata.packageRoot,
+            assetRoot,
+            hashesPresent,
+        };
+        let exitCode;
+        try {
+            exitCode = await injectOne.injectOne(target, scope, flags, originCwd);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.logger.error(`${target.name}: ${msg}`);
+            exitCode = 1;
+        }
+        if (exitCode !== 0) {
+            if (fatalOnError)
+                process.exit(exitCode);
+            failureCount += 1;
+        }
+    }
+    if (failureCount > 0)
+        process.exit(1);
+}
+
+exports.runInject = runInject;

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

@@ -0,0 +1,3 @@
+import type { DefaultFlags } from '../type.js';
+import type { ResolvedMetadata } from './resolvePackage.js';
+export declare function runInject(flags: DefaultFlags, metadataList: readonly ResolvedMetadata[]): Promise<void>;

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

@@ -0,0 +1,50 @@
+import { stat } from 'node:fs/promises';
+import { isAbsolute, resolve, join } from 'node:path';
+import { logger } from '../../../utils/logger.mjs';
+import { injectOne } from './injectOne.mjs';
+import { resolveScopeFlag } from './resolveScopeFlag.mjs';
+
+async function runInject(flags, metadataList) {
+    if (metadataList.length === 0)
+        return;
+    for (const metadata of metadataList) {
+        if (!isAbsolute(metadata.packageRoot)) {
+            logger.error(`packageRoot must be an absolute path; received: ${metadata.packageRoot}`);
+            process.exit(2);
+        }
+    }
+    const originCwd = flags.root ?? process.cwd();
+    const scope = await resolveScopeFlag(flags.scope);
+    const fatalOnError = metadataList.length === 1;
+    let failureCount = 0;
+    for (const metadata of metadataList) {
+        const assetRoot = resolve(metadata.packageRoot, metadata.assetPath);
+        const hashesPath = join(metadata.packageRoot, 'dist', 'claude-hashes.json');
+        const hashesPresent = await stat(hashesPath).then(() => true, () => false);
+        const target = {
+            name: metadata.packageName,
+            version: metadata.packageVersion,
+            packageRoot: metadata.packageRoot,
+            assetRoot,
+            hashesPresent,
+        };
+        let exitCode;
+        try {
+            exitCode = await injectOne(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)
+                process.exit(exitCode);
+            failureCount += 1;
+        }
+    }
+    if (failureCount > 0)
+        process.exit(1);
+}
+
+export { runInject };

package/dist/core/buildPlan/buildPlan.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var node_path = require('node:path');
+var hash = require('../hash/hash.cjs');
+var toPosix = require('./utils/toPosix.cjs');
+var walkFiles = require('./utils/walkFiles.cjs');
+
+async function buildPlan(input) {
+    const { sourceHashes, targetRoot, namespacePrefixes, force } = input;
+    const actions = [];
+    let requiresForce = false;
+    for (const [relPath, srcHash] of Object.entries(sourceHashes)) {
+        const dstAbs = node_path.join(targetRoot, relPath);
+        const dstHash = await hash.hashFile(dstAbs);
+        if (dstHash === null)
+            actions.push({ kind: 'copy', relPath, dstAbs });
+        else if (hash.hashEquals(dstHash, srcHash))
+            actions.push({ kind: 'skip-uptodate', relPath, dstAbs });
+        else {
+            actions.push({ kind: 'warn-diverged', relPath, dstAbs });
+            requiresForce = true;
+        }
+    }
+    const known = new Set(Object.keys(sourceHashes));
+    for (const prefix of namespacePrefixes) {
+        const prefixRoot = node_path.join(targetRoot, prefix);
+        for await (const abs of walkFiles.walkFiles(prefixRoot)) {
+            const relPath = toPosix.toPosix(node_path.relative(targetRoot, abs));
+            if (known.has(relPath))
+                continue;
+            if (force)
+                actions.push({ kind: 'delete', relPath, dstAbs: abs });
+            else {
+                actions.push({ kind: 'warn-orphan', relPath, dstAbs: abs });
+                requiresForce = true;
+            }
+        }
+    }
+    return { actions, requiresForce };
+}
+
+exports.buildPlan = buildPlan;

package/dist/core/buildPlan/buildPlan.d.ts

@@ -0,0 +1,2 @@
+import type { InjectPlan, PlanInput } from './type.js';
+export declare function buildPlan(input: PlanInput): Promise<InjectPlan>;

package/dist/core/buildPlan/buildPlan.mjs

@@ -0,0 +1,40 @@
+import { join, relative } from 'node:path';
+import { hashFile, hashEquals } from '../hash/hash.mjs';
+import { toPosix } from './utils/toPosix.mjs';
+import { walkFiles } from './utils/walkFiles.mjs';
+
+async function buildPlan(input) {
+    const { sourceHashes, targetRoot, namespacePrefixes, force } = input;
+    const actions = [];
+    let requiresForce = false;
+    for (const [relPath, srcHash] of Object.entries(sourceHashes)) {
+        const dstAbs = join(targetRoot, relPath);
+        const dstHash = await hashFile(dstAbs);
+        if (dstHash === null)
+            actions.push({ kind: 'copy', relPath, dstAbs });
+        else if (hashEquals(dstHash, srcHash))
+            actions.push({ kind: 'skip-uptodate', relPath, dstAbs });
+        else {
+            actions.push({ kind: 'warn-diverged', relPath, dstAbs });
+            requiresForce = true;
+        }
+    }
+    const known = new Set(Object.keys(sourceHashes));
+    for (const prefix of namespacePrefixes) {
+        const prefixRoot = join(targetRoot, prefix);
+        for await (const abs of walkFiles(prefixRoot)) {
+            const relPath = toPosix(relative(targetRoot, abs));
+            if (known.has(relPath))
+                continue;
+            if (force)
+                actions.push({ kind: 'delete', relPath, dstAbs: abs });
+            else {
+                actions.push({ kind: 'warn-orphan', relPath, dstAbs: abs });
+                requiresForce = true;
+            }
+        }
+    }
+    return { actions, requiresForce };
+}
+
+export { buildPlan };

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

@@ -0,0 +1,2 @@
+export { buildPlan } from './buildPlan.js';
+export type { Action, InjectPlan, PlanInput } from './type.js';

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

@@ -0,0 +1,32 @@
+import type { Sha256Hex } from '../hash/index.js';
+export type Action = {
+    kind: 'copy';
+    relPath: string;
+    dstAbs: string;
+} | {
+    kind: 'skip-uptodate';
+    relPath: string;
+    dstAbs: string;
+} | {
+    kind: 'warn-diverged';
+    relPath: string;
+    dstAbs: string;
+} | {
+    kind: 'warn-orphan';
+    relPath: string;
+    dstAbs: string;
+} | {
+    kind: 'delete';
+    relPath: string;
+    dstAbs: string;
+};
+export interface InjectPlan {
+    actions: Action[];
+    requiresForce: boolean;
+}
+export interface PlanInput {
+    sourceHashes: Record<string, Sha256Hex>;
+    targetRoot: string;
+    namespacePrefixes: string[];
+    force: boolean;
+}

package/dist/core/buildPlan/utils/toPosix.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var node_path = require('node:path');
+
+function toPosix(p) {
+    return node_path.sep === '/' ? p : p.split(node_path.sep).join('/');
+}
+
+exports.toPosix = toPosix;

package/dist/core/buildPlan/utils/toPosix.d.ts

@@ -0,0 +1 @@
+export declare function toPosix(p: string): string;

package/dist/core/buildPlan/utils/toPosix.mjs

@@ -0,0 +1,7 @@
+import { sep } from 'node:path';
+
+function toPosix(p) {
+    return sep === '/' ? p : p.split(sep).join('/');
+}
+
+export { toPosix };

package/dist/core/buildPlan/utils/walkFiles.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var node_path = require('node:path');
+
+async function* walkFiles(root) {
+    let entries;
+    try {
+        entries = await promises.readdir(root, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return;
+        throw err;
+    }
+    for (const entry of entries) {
+        const abs = node_path.join(root, entry.name);
+        if (entry.isDirectory())
+            yield* walkFiles(abs);
+        else if (entry.isFile())
+            yield abs;
+    }
+}
+
+exports.walkFiles = walkFiles;

package/dist/core/buildPlan/utils/walkFiles.d.ts

@@ -0,0 +1 @@
+export declare function walkFiles(root: string): AsyncGenerator<string>;

package/dist/core/buildPlan/utils/walkFiles.mjs

@@ -0,0 +1,23 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+
+async function* walkFiles(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* walkFiles(abs);
+        else if (entry.isFile())
+            yield abs;
+    }
+}
+
+export { walkFiles };

package/dist/core/hash/hash.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var node_crypto = require('node:crypto');
+var promises = require('node:fs/promises');
+
+function hashContent(buffer) {
+    return node_crypto.createHash('sha256').update(buffer).digest('hex');
+}
+async function hashFile(absPath) {
+    try {
+        const buf = await promises.readFile(absPath);
+        return hashContent(buf);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+function hashEquals(a, b) {
+    if (a === null || b === null)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    return a.toLowerCase() === b.toLowerCase();
+}
+
+exports.hashContent = hashContent;
+exports.hashEquals = hashEquals;
+exports.hashFile = hashFile;

package/dist/core/hash/hash.d.ts

@@ -0,0 +1,4 @@
+export type Sha256Hex = string;
+export declare function hashContent(buffer: Buffer | string): Sha256Hex;
+export declare function hashFile(absPath: string): Promise<Sha256Hex | null>;
+export declare function hashEquals(a: Sha256Hex | null, b: Sha256Hex | null): boolean;

package/dist/core/hash/hash.mjs

@@ -0,0 +1,26 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+
+function hashContent(buffer) {
+    return createHash('sha256').update(buffer).digest('hex');
+}
+async function hashFile(absPath) {
+    try {
+        const buf = await readFile(absPath);
+        return hashContent(buf);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+function hashEquals(a, b) {
+    if (a === null || b === null)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    return a.toLowerCase() === b.toLowerCase();
+}
+
+export { hashContent, hashEquals, hashFile };