@slats/claude-assets-sync 0.1.4 → 0.2.0

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 };

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

@@ -0,0 +1 @@
+export { hashContent, hashFile, hashEquals, type Sha256Hex } from './hash.js';

package/dist/core/hashManifest/hashManifest.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var node_path = require('node:path');
+
+const HASH_MANIFEST_FILENAME = 'claude-hashes.json';
+async function readHashManifest(packageRoot) {
+    const primary = node_path.join(packageRoot, 'dist', HASH_MANIFEST_FILENAME);
+    const raw = await promises.readFile(primary, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== 1)
+        throw new Error(`[claude-assets-sync] Unsupported manifest schemaVersion: ${parsed.schemaVersion}`);
+    return parsed;
+}
+function computeNamespacePrefixes(manifest) {
+    const prefixes = new Set();
+    for (const relPath of Object.keys(manifest.files)) {
+        const parts = relPath.split('/');
+        if (parts.length >= 3 && parts[0] === 'skills')
+            prefixes.add(`${parts[0]}/${parts[1]}/`);
+    }
+    return [...prefixes];
+}
+
+exports.HASH_MANIFEST_FILENAME = HASH_MANIFEST_FILENAME;
+exports.computeNamespacePrefixes = computeNamespacePrefixes;
+exports.readHashManifest = readHashManifest;

package/dist/core/hashManifest/hashManifest.d.ts

@@ -0,0 +1,17 @@
+import type { Sha256Hex } from '../hash/index.js';
+export interface HashManifest {
+    schemaVersion: 1;
+    package: {
+        name: string;
+        version: string;
+    };
+    generatedAt: string;
+    algorithm: 'sha256';
+    assetRoot: string;
+    files: Record<string, Sha256Hex>;
+    previousVersions: Record<string, never>;
+}
+export declare const HASH_MANIFEST_FILENAME = "claude-hashes.json";
+export declare function readHashManifest(packageRoot: string): Promise<HashManifest>;
+/** Derive the set of managed namespace prefixes (e.g., "skills/<expert>/") from manifest file paths. */
+export declare function computeNamespacePrefixes(manifest: HashManifest): string[];

package/dist/core/hashManifest/hashManifest.mjs

@@ -0,0 +1,23 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const HASH_MANIFEST_FILENAME = 'claude-hashes.json';
+async function readHashManifest(packageRoot) {
+    const primary = join(packageRoot, 'dist', HASH_MANIFEST_FILENAME);
+    const raw = await readFile(primary, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== 1)
+        throw new Error(`[claude-assets-sync] Unsupported manifest schemaVersion: ${parsed.schemaVersion}`);
+    return parsed;
+}
+function computeNamespacePrefixes(manifest) {
+    const prefixes = new Set();
+    for (const relPath of Object.keys(manifest.files)) {
+        const parts = relPath.split('/');
+        if (parts.length >= 3 && parts[0] === 'skills')
+            prefixes.add(`${parts[0]}/${parts[1]}/`);
+    }
+    return [...prefixes];
+}
+
+export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, readHashManifest };

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

@@ -0,0 +1 @@
+export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, readHashManifest, type HashManifest, } from './hashManifest.js';

package/dist/core/index.d.ts

@@ -0,0 +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 { buildPlan, type Action, type InjectPlan, type PlanInput, } from './buildPlan/index.js';
+export { findNearestDotClaudeAncestor, isInteractive, isValidScope, resolveScope, type Scope, type ScopeResolution, } from './scope/index.js';

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

@@ -0,0 +1,2 @@
+export { injectDocs } from './injectDocs.js';
+export type { InjectOptions, InjectReport } from './type.js';

package/dist/core/injectDocs/injectDocs.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var asyncPool = require('../../utils/asyncPool.cjs');
+var logger = require('../../utils/logger.cjs');
+var buildPlan = require('../buildPlan/buildPlan.cjs');
+var hashManifest = require('../hashManifest/hashManifest.cjs');
+var scope = require('../scope/scope.cjs');
+var applyAction = require('./utils/applyAction.cjs');
+var emitCiForceList = require('./utils/emitCiForceList.cjs');
+var printPlan = require('./utils/printPlan.cjs');
+var summarize = require('./utils/summarize.cjs');
+
+async function injectDocs(opts) {
+    const manifest = await hashManifest.readHashManifest(opts.packageRoot);
+    const resolution = scope.resolveScope(opts.scope, opts.originCwd ?? process.cwd());
+    const plan = await buildPlan.buildPlan({
+        sourceHashes: manifest.files,
+        targetRoot: resolution.targetRoot,
+        namespacePrefixes: hashManifest.computeNamespacePrefixes(manifest),
+        force: opts.force,
+    });
+    logger.logger.info(`${opts.packageName}@${opts.packageVersion} → ${resolution.description}`);
+    printPlan.printPlan(plan);
+    if (plan.requiresForce && !opts.force) {
+        logger.logger.error('Re-run with --force to proceed, or inspect with --dry-run.');
+        return summarize.summarize(plan, 2);
+    }
+    if (opts.force &&
+        plan.actions.some((a) => a.kind === 'warn-diverged' || a.kind === 'warn-orphan')) {
+        if (!scope.isInteractive())
+            emitCiForceList.emitCiForceList(plan);
+        else if (opts.confirmForce && !(await opts.confirmForce(plan)))
+            return summarize.summarize(plan, 2);
+    }
+    if (opts.dryRun) {
+        logger.logger.warn('[DRY RUN] No files will be created, overwritten, or deleted.');
+        return summarize.summarize(plan, 0);
+    }
+    await asyncPool.asyncPool(8, plan.actions, (action) => applyAction.applyAction(action, opts.assetRoot));
+    return summarize.summarize(plan, 0);
+}
+
+exports.injectDocs = injectDocs;

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

@@ -0,0 +1,2 @@
+import type { InjectOptions, InjectReport } from './type.js';
+export declare function injectDocs(opts: InjectOptions): Promise<InjectReport>;

package/dist/core/injectDocs/injectDocs.mjs

@@ -0,0 +1,41 @@
+import { asyncPool } from '../../utils/asyncPool.mjs';
+import { logger } from '../../utils/logger.mjs';
+import { buildPlan } from '../buildPlan/buildPlan.mjs';
+import { readHashManifest, computeNamespacePrefixes } from '../hashManifest/hashManifest.mjs';
+import { resolveScope, isInteractive } from '../scope/scope.mjs';
+import { applyAction } from './utils/applyAction.mjs';
+import { emitCiForceList } from './utils/emitCiForceList.mjs';
+import { printPlan } from './utils/printPlan.mjs';
+import { summarize } from './utils/summarize.mjs';
+
+async function injectDocs(opts) {
+    const manifest = await readHashManifest(opts.packageRoot);
+    const resolution = resolveScope(opts.scope, opts.originCwd ?? process.cwd());
+    const plan = await buildPlan({
+        sourceHashes: manifest.files,
+        targetRoot: resolution.targetRoot,
+        namespacePrefixes: computeNamespacePrefixes(manifest),
+        force: opts.force,
+    });
+    logger.info(`${opts.packageName}@${opts.packageVersion} → ${resolution.description}`);
+    printPlan(plan);
+    if (plan.requiresForce && !opts.force) {
+        logger.error('Re-run with --force to proceed, or inspect with --dry-run.');
+        return summarize(plan, 2);
+    }
+    if (opts.force &&
+        plan.actions.some((a) => a.kind === 'warn-diverged' || a.kind === 'warn-orphan')) {
+        if (!isInteractive())
+            emitCiForceList(plan);
+        else if (opts.confirmForce && !(await opts.confirmForce(plan)))
+            return summarize(plan, 2);
+    }
+    if (opts.dryRun) {
+        logger.warn('[DRY RUN] No files will be created, overwritten, or deleted.');
+        return summarize(plan, 0);
+    }
+    await asyncPool(8, plan.actions, (action) => applyAction(action, opts.assetRoot));
+    return summarize(plan, 0);
+}
+
+export { injectDocs };

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

@@ -0,0 +1,30 @@
+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[];
+    skipped: string[];
+    warnings: {
+        relPath: string;
+        reason: string;
+    }[];
+    deleted: string[];
+    exitCode: 0 | 1 | 2;
+}

package/dist/core/injectDocs/utils/applyAction.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var node_path = require('node:path');
+var logger = require('../../../utils/logger.cjs');
+
+async function applyAction(action, assetRoot) {
+    if (action.kind === 'copy') {
+        const srcAbs = node_path.join(assetRoot, action.relPath);
+        await promises.mkdir(node_path.dirname(action.dstAbs), { recursive: true });
+        await promises.copyFile(srcAbs, action.dstAbs);
+    }
+    else if (action.kind === 'delete')
+        await promises.unlink(action.dstAbs).catch((error) => {
+            if (error?.code !== 'ENOENT') {
+                logger.logger.warn(`[claude-sync] unlink failed: ${action.dstAbs} (${error?.code ?? error})`);
+            }
+        });
+}
+
+exports.applyAction = applyAction;

package/dist/core/injectDocs/utils/applyAction.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from '../../buildPlan/index.js';
+export declare function applyAction(action: Action, assetRoot: string): Promise<void>;

package/dist/core/injectDocs/utils/applyAction.mjs

@@ -0,0 +1,19 @@
+import { mkdir, copyFile, unlink } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { logger } from '../../../utils/logger.mjs';
+
+async function applyAction(action, assetRoot) {
+    if (action.kind === 'copy') {
+        const srcAbs = join(assetRoot, action.relPath);
+        await mkdir(dirname(action.dstAbs), { recursive: true });
+        await copyFile(srcAbs, action.dstAbs);
+    }
+    else if (action.kind === 'delete')
+        await unlink(action.dstAbs).catch((error) => {
+            if (error?.code !== 'ENOENT') {
+                logger.warn(`[claude-sync] unlink failed: ${action.dstAbs} (${error?.code ?? error})`);
+            }
+        });
+}
+
+export { applyAction };

package/dist/core/injectDocs/utils/emitCiForceList.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+function emitCiForceList(plan) {
+    const divergent = plan.actions.filter((a) => a.kind === 'warn-diverged' || a.kind === 'warn-orphan');
+    process.stderr.write(`[claude-assets-sync] --force overwriting ${divergent.length} file(s) in non-TTY mode:\n`);
+    for (const a of divergent)
+        process.stderr.write(`  ${a.relPath}\n`);
+}
+
+exports.emitCiForceList = emitCiForceList;

package/dist/core/injectDocs/utils/emitCiForceList.d.ts

@@ -0,0 +1,2 @@
+import type { InjectPlan } from '../../buildPlan/index.js';
+export declare function emitCiForceList(plan: InjectPlan): void;

package/dist/core/injectDocs/utils/emitCiForceList.mjs

@@ -0,0 +1,8 @@
+function emitCiForceList(plan) {
+    const divergent = plan.actions.filter((a) => a.kind === 'warn-diverged' || a.kind === 'warn-orphan');
+    process.stderr.write(`[claude-assets-sync] --force overwriting ${divergent.length} file(s) in non-TTY mode:\n`);
+    for (const a of divergent)
+        process.stderr.write(`  ${a.relPath}\n`);
+}
+
+export { emitCiForceList };

package/dist/core/injectDocs/utils/printPlan.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var logger = require('../../../utils/logger.cjs');
+
+function printPlan(plan) {
+    for (const a of plan.actions) {
+        if (a.kind === 'copy')
+            logger.logger.file('create', a.relPath);
+        else if (a.kind === 'skip-uptodate')
+            logger.logger.file('skip', `${a.relPath} (up-to-date)`);
+        else if (a.kind === 'warn-diverged')
+            logger.logger.warn(`${a.relPath} — local differs from source (user edit or version change)`);
+        else if (a.kind === 'warn-orphan')
+            logger.logger.warn(`${a.relPath} — present locally, absent in source`);
+        else if (a.kind === 'delete')
+            logger.logger.file('update', `${a.relPath} (deleting)`);
+    }
+}
+
+exports.printPlan = printPlan;

package/dist/core/injectDocs/utils/printPlan.d.ts

@@ -0,0 +1,2 @@
+import type { InjectPlan } from '../../buildPlan/index.js';
+export declare function printPlan(plan: InjectPlan): void;

package/dist/core/injectDocs/utils/printPlan.mjs

@@ -0,0 +1,18 @@
+import { logger } from '../../../utils/logger.mjs';
+
+function printPlan(plan) {
+    for (const a of plan.actions) {
+        if (a.kind === 'copy')
+            logger.file('create', a.relPath);
+        else if (a.kind === 'skip-uptodate')
+            logger.file('skip', `${a.relPath} (up-to-date)`);
+        else if (a.kind === 'warn-diverged')
+            logger.warn(`${a.relPath} — local differs from source (user edit or version change)`);
+        else if (a.kind === 'warn-orphan')
+            logger.warn(`${a.relPath} — present locally, absent in source`);
+        else if (a.kind === 'delete')
+            logger.file('update', `${a.relPath} (deleting)`);
+    }
+}
+
+export { printPlan };

package/dist/core/injectDocs/utils/summarize.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+function summarize(plan, exitCode) {
+    const report = {
+        created: [],
+        updated: [],
+        skipped: [],
+        warnings: [],
+        deleted: [],
+        exitCode,
+    };
+    for (const a of plan.actions) {
+        if (a.kind === 'copy')
+            report.created.push(a.relPath);
+        else if (a.kind === 'skip-uptodate')
+            report.skipped.push(a.relPath);
+        else if (a.kind === 'warn-diverged')
+            report.warnings.push({ relPath: a.relPath, reason: 'diverged' });
+        else if (a.kind === 'warn-orphan')
+            report.warnings.push({ relPath: a.relPath, reason: 'orphan' });
+        else if (a.kind === 'delete')
+            report.deleted.push(a.relPath);
+    }
+    return report;
+}
+
+exports.summarize = summarize;

package/dist/core/injectDocs/utils/summarize.d.ts

@@ -0,0 +1,3 @@
+import type { InjectPlan } from '../../buildPlan/index.js';
+import type { InjectReport } from '../type.js';
+export declare function summarize(plan: InjectPlan, exitCode: 0 | 1 | 2): InjectReport;

package/dist/core/injectDocs/utils/summarize.mjs

@@ -0,0 +1,25 @@
+function summarize(plan, exitCode) {
+    const report = {
+        created: [],
+        updated: [],
+        skipped: [],
+        warnings: [],
+        deleted: [],
+        exitCode,
+    };
+    for (const a of plan.actions) {
+        if (a.kind === 'copy')
+            report.created.push(a.relPath);
+        else if (a.kind === 'skip-uptodate')
+            report.skipped.push(a.relPath);
+        else if (a.kind === 'warn-diverged')
+            report.warnings.push({ relPath: a.relPath, reason: 'diverged' });
+        else if (a.kind === 'warn-orphan')
+            report.warnings.push({ relPath: a.relPath, reason: 'orphan' });
+        else if (a.kind === 'delete')
+            report.deleted.push(a.relPath);
+    }
+    return report;
+}
+
+export { summarize };

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

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

package/dist/core/scope/scope.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var node_os = require('node:os');
+var node_path = require('node:path');
+var isDirectory = require('./utils/isDirectory.cjs');
+
+function isValidScope(value) {
+    return value === 'user' || value === 'project';
+}
+function findNearestDotClaudeAncestor(start) {
+    let current = start;
+    while (true) {
+        if (isDirectory.isDirectory(node_path.join(current, '.claude')))
+            return current;
+        const parent = node_path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function resolveScope(scope, cwd = process.cwd()) {
+    if (scope === 'user') {
+        return {
+            scope,
+            targetRoot: node_path.join(node_os.homedir(), '.claude'),
+            description: '~/.claude (user)',
+        };
+    }
+    const ancestor = findNearestDotClaudeAncestor(cwd);
+    const base = ancestor ?? cwd;
+    return {
+        scope,
+        targetRoot: node_path.join(base, '.claude'),
+        description: ancestor !== null
+            ? `${base}/.claude (project, auto-located)`
+            : `${base}/.claude (project)`,
+    };
+}
+function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+exports.findNearestDotClaudeAncestor = findNearestDotClaudeAncestor;
+exports.isInteractive = isInteractive;
+exports.isValidScope = isValidScope;
+exports.resolveScope = resolveScope;

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

@@ -0,0 +1,16 @@
+export type Scope = 'user' | 'project';
+export interface ScopeResolution {
+    scope: Scope;
+    targetRoot: string;
+    description: string;
+}
+export declare function isValidScope(value: unknown): value is Scope;
+/**
+ * Walk parent directories of `start` and return the first ancestor that
+ * already contains a `.claude` directory. Returns the ancestor path itself
+ * (not `/.claude`), or `null` when no such ancestor exists up to the
+ * filesystem root. `start` itself is considered as the first candidate.
+ */
+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

@@ -0,0 +1,41 @@
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { isDirectory } from './utils/isDirectory.mjs';
+
+function isValidScope(value) {
+    return value === 'user' || value === 'project';
+}
+function findNearestDotClaudeAncestor(start) {
+    let current = start;
+    while (true) {
+        if (isDirectory(join(current, '.claude')))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function resolveScope(scope, cwd = process.cwd()) {
+    if (scope === 'user') {
+        return {
+            scope,
+            targetRoot: join(homedir(), '.claude'),
+            description: '~/.claude (user)',
+        };
+    }
+    const ancestor = findNearestDotClaudeAncestor(cwd);
+    const base = ancestor ?? cwd;
+    return {
+        scope,
+        targetRoot: join(base, '.claude'),
+        description: ancestor !== null
+            ? `${base}/.claude (project, auto-located)`
+            : `${base}/.claude (project)`,
+    };
+}
+function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+export { findNearestDotClaudeAncestor, isInteractive, isValidScope, resolveScope };

package/dist/core/scope/utils/isDirectory.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var node_fs = require('node:fs');
+
+function isDirectory(path) {
+    try {
+        return node_fs.statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+
+exports.isDirectory = isDirectory;

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

@@ -0,0 +1 @@
+export declare function isDirectory(path: string): boolean;

package/dist/core/scope/utils/isDirectory.mjs

@@ -0,0 +1,12 @@
+import { statSync } from 'node:fs';
+
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+
+export { isDirectory };