@slats/claude-assets-sync 0.1.3 → 0.2.0

package/bin/claude-sync.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { runCli } from '@slats/claude-assets-sync';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const pkg = JSON.parse(
+  await readFile(resolve(packageRoot, 'package.json'), 'utf-8'),
+);
+
+if (typeof pkg.claude?.assetPath === 'string') {
+  runCli(process.argv, {
+    packageRoot,
+    packageName: pkg.name,
+    packageVersion: pkg.version,
+    assetPath: pkg.claude.assetPath,
+  }).catch((err) => {
+    process.stderr.write(
+      `[${pkg.name}] claude-sync failed: ${err instanceof Error ? err.message : String(err)}\n`,
+    );
+    process.exit(1);
+  });
+}

package/dist/@aileron/declare/index.d.ts

@@ -1,4 +1,4 @@
-export * from './function';
-export * from './object';
-export * from './utility';
-export * from './unit';
+export * from './function.js';
+export * from './object.js';
+export * from './utility.js';
+export * from './unit.js';

package/dist/claude-hashes.json

@@ -0,0 +1,20 @@
+{
+  "schemaVersion": 1,
+  "package": {
+    "name": "@slats/claude-assets-sync",
+    "version": "0.2.0"
+  },
+  "generatedAt": "2026-04-24T04:25:43.386Z",
+  "algorithm": "sha256",
+  "assetRoot": "docs/claude",
+  "files": {
+    "skills/claude-sync-applier/SKILL.md": "1c846b7ff7b127217a3201028ec4e1476857e5a5bb38b92d863b92a16ac4c7d0",
+    "skills/claude-sync-applier/knowledge/claude-md-template.md": "966fcc668b0e8f43ae83a6111ba1887d5504182e0b138e19937abb1fb43b3318",
+    "skills/claude-sync-applier/knowledge/dependency-cruiser.md": "058de112be3c03999846a66d066be540f72f2b1c40f5a1d04a82d36236a3c562",
+    "skills/claude-sync-applier/knowledge/gotchas.md": "310ffb416cbcaaf4b9162d0e6004dead6a8d658ff693ffe9e8580a8b83f7b6ea",
+    "skills/claude-sync-applier/knowledge/package-json-patches.md": "3ef1c39800e541e6390575a5296a8a247772b58c126c30149cd1efa61ead5dcc",
+    "skills/claude-sync-applier/knowledge/reference-files.md": "d0d42df1f90b17d8a35e914bfd16fe381890d71e0ea6a767d1e5e14874f2b95f",
+    "skills/claude-sync-applier/knowledge/smoke-tests.md": "76c396e2c7d410920139c894fc52d74e9914ea59d0e41dc30ebfe106e99c4be3"
+  },
+  "previousVersions": {}
+}

package/dist/commands/index.d.ts

@@ -1,112 +1 @@
-/**
- * Command registry and exports
- */
-export * from './types';
-export { runSyncCommand } from './sync';
-export { runListCommand, registerListCommand } from './list';
-export { runRemoveCommand } from './remove';
-export { runStatusCommand } from './status';
-export { runMigrateCommand } from './migrate';
-export { runAddCommand } from './add';
-export { runUpdateCommand } from './update';
-export type { UpdateCommandOptions } from './update';
-/**
- * Command metadata for CLI help and documentation
- */
-export declare const COMMANDS: {
-    readonly sync: {
-        readonly name: "sync";
-        readonly description: "Sync Claude assets from npm packages";
-        readonly options: readonly [{
-            readonly flag: "-p, --package <name>";
-            readonly description: "Package name to sync";
-        }, {
-            readonly flag: "-f, --force";
-            readonly description: "Force sync even if version matches";
-        }, {
-            readonly flag: "--dry-run";
-            readonly description: "Preview changes without writing files";
-        }, {
-            readonly flag: "-l, --local";
-            readonly description: "Read from local workspace";
-        }, {
-            readonly flag: "-r, --ref <ref>";
-            readonly description: "Git ref to fetch from";
-        }, {
-            readonly flag: "--no-flat";
-            readonly description: "Use legacy nested structure";
-        }];
-    };
-    readonly add: {
-        readonly name: "add";
-        readonly description: "Add a package with interactive asset selection";
-        readonly options: readonly [{
-            readonly flag: "-p, --package <name>";
-            readonly description: "Package name to add";
-        }, {
-            readonly flag: "-l, --local";
-            readonly description: "Read from local workspace";
-        }, {
-            readonly flag: "-r, --ref <ref>";
-            readonly description: "Git ref to fetch from";
-        }];
-    };
-    readonly list: {
-        readonly name: "list";
-        readonly description: "List all synced packages";
-        readonly options: readonly [{
-            readonly flag: "--json";
-            readonly description: "Output as JSON";
-        }];
-    };
-    readonly remove: {
-        readonly name: "remove";
-        readonly description: "Remove a synced package";
-        readonly options: readonly [{
-            readonly flag: "-p, --package <name>";
-            readonly description: "Package name to remove";
-        }, {
-            readonly flag: "-y, --yes";
-            readonly description: "Skip confirmation prompt";
-        }, {
-            readonly flag: "--dry-run";
-            readonly description: "Preview changes without removing files";
-        }];
-    };
-    readonly status: {
-        readonly name: "status";
-        readonly description: "Show sync status of all packages";
-        readonly options: readonly [{
-            readonly flag: "--no-remote";
-            readonly description: "Skip remote version check";
-        }];
-    };
-    readonly migrate: {
-        readonly name: "migrate";
-        readonly description: "Migrate from legacy to flat structure";
-        readonly options: readonly [{
-            readonly flag: "--dry-run";
-            readonly description: "Preview migration without making changes";
-        }];
-    };
-    readonly update: {
-        readonly name: "update";
-        readonly description: "Update package metadata in .sync-meta.json";
-        readonly options: readonly [{
-            readonly flag: "-p, --package <name>";
-            readonly description: "Package name to update (default: all)";
-        }, {
-            readonly flag: "-l, --local";
-            readonly description: "Read from local workspace";
-        }, {
-            readonly flag: "-r, --ref <ref>";
-            readonly description: "Git ref to fetch from";
-        }, {
-            readonly flag: "--dry-run";
-            readonly description: "Preview changes without writing";
-        }, {
-            readonly flag: "--sync";
-            readonly description: "Re-sync files after updating metadata";
-        }];
-    };
-};
+export { runCli, type DefaultFlags, type RunCliOptions, } from './runCli/index.js';

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

@@ -0,0 +1,2 @@
+export { runCli } from './runCli.js';
+export type { DefaultFlags, RunCliOptions } from './type.js';

package/dist/commands/runCli/runCli.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var commander = require('commander');
+var logger = require('../../utils/logger.cjs');
+var version = require('../../utils/version.cjs');
+var runInject = require('./utils/runInject.cjs');
+
+async function runCli(argv = process.argv, options) {
+    const cmd = new commander.Command();
+    cmd
+        .name('claude-sync')
+        .description("Inject this package's assets into the target .claude directory")
+        .version(options.version ?? version.VERSION)
+        .option('--scope <scope>', 'Target scope: user (~/.claude) | project (nearest ancestor .claude or <cwd>/.claude)')
+        .option('--dry-run', 'Preview without writing', false)
+        .option('--force', 'Overwrite user modifications', false)
+        .option('--root <path>', 'Override scope resolution cwd (default: cwd)')
+        .action(async (flags) => {
+        await runInject.runInject(flags, options);
+    });
+    try {
+        await cmd.parseAsync([...argv]);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.logger.error(msg);
+        process.exit(1);
+    }
+}
+
+exports.runCli = runCli;

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

@@ -0,0 +1,10 @@
+import type { RunCliOptions } from './type.js';
+/**
+ * CLI entry for `@slats/claude-assets-sync`.
+ *
+ * The caller passes its own package metadata (`packageRoot`, `packageName`,
+ * `packageVersion`, `assetPath`) so the library never walks the filesystem
+ * looking for consumers. Consumer bin stubs read their own `package.json`
+ * and forward the resolved values here.
+ */
+export declare function runCli(argv: readonly string[] | undefined, options: RunCliOptions): Promise<void>;

package/dist/commands/runCli/runCli.mjs

@@ -0,0 +1,29 @@
+import { Command } from 'commander';
+import { logger } from '../../utils/logger.mjs';
+import { VERSION } from '../../utils/version.mjs';
+import { runInject } from './utils/runInject.mjs';
+
+async function runCli(argv = process.argv, options) {
+    const cmd = new Command();
+    cmd
+        .name('claude-sync')
+        .description("Inject this package's assets into the target .claude directory")
+        .version(options.version ?? VERSION)
+        .option('--scope <scope>', 'Target scope: user (~/.claude) | project (nearest ancestor .claude or <cwd>/.claude)')
+        .option('--dry-run', 'Preview without writing', false)
+        .option('--force', 'Overwrite user modifications', false)
+        .option('--root <path>', 'Override scope resolution cwd (default: cwd)')
+        .action(async (flags) => {
+        await runInject(flags, options);
+    });
+    try {
+        await cmd.parseAsync([...argv]);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.error(msg);
+        process.exit(1);
+    }
+}
+
+export { runCli };

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

@@ -0,0 +1,28 @@
+export interface RunCliOptions {
+    version?: string;
+    /** Absolute filesystem path to the consumer package root. */
+    packageRoot: string;
+    /** Consumer package name used in logs and error messages. */
+    packageName: string;
+    /** Consumer package version used in logs. */
+    packageVersion: string;
+    /** Asset directory path relative to `packageRoot`. */
+    assetPath: string;
+}
+export interface DefaultFlags {
+    scope?: string;
+    dryRun?: boolean;
+    force?: boolean;
+    root?: string;
+}
+/**
+ * Resolved consumer metadata passed to the injection pipeline.
+ * The caller owns the definition; the library does not read `package.json`.
+ */
+export interface ConsumerPackage {
+    name: string;
+    version: string;
+    packageRoot: string;
+    assetRoot: string;
+    hashesPresent: boolean;
+}

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

@@ -0,0 +1,48 @@
+'use strict';
+
+require('node:crypto');
+require('node:fs/promises');
+require('node:path');
+var injectDocs = require('../../../core/injectDocs/injectDocs.cjs');
+require('node:os');
+require('node:fs');
+require('@inquirer/prompts');
+require('picocolors');
+var confirmForce = require('../../../prompts/confirmForce.cjs');
+var heartbeat = require('../../../utils/heartbeat.cjs');
+var logger = require('../../../utils/logger.cjs');
+
+async function injectOne(target, scope, flags, originCwd) {
+    if (!target.hashesPresent) {
+        logger.logger.warn(`${target.name}: dist/claude-hashes.json missing — build the package (e.g. yarn build) to regenerate the hash manifest first.`);
+        return;
+    }
+    logger.logger.heading(`${target.name}@${target.version}`);
+    const stopHeartbeat = heartbeat.startHeartbeat({
+        label: `injecting ${target.name}`,
+    });
+    try {
+        const report = await injectDocs.injectDocs({
+            packageName: target.name,
+            packageVersion: target.version,
+            packageRoot: target.packageRoot,
+            assetRoot: target.assetRoot,
+            scope,
+            originCwd,
+            dryRun: flags.dryRun ?? false,
+            force: flags.force ?? false,
+            confirmForce: async (plan) => {
+                const diverged = plan.actions.filter((a) => a.kind === 'warn-diverged');
+                const orphans = plan.actions.filter((a) => a.kind === 'warn-orphan');
+                return confirmForce.confirmForceAsync(diverged.length, orphans.length, [...diverged, ...orphans].map((a) => a.relPath).slice(0, 3));
+            },
+        });
+        if (report.exitCode !== 0)
+            process.exit(report.exitCode);
+    }
+    finally {
+        stopHeartbeat();
+    }
+}
+
+exports.injectOne = injectOne;

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

@@ -0,0 +1,3 @@
+import { type Scope } from '../../../core/index.js';
+import type { ConsumerPackage, DefaultFlags } from '../type.js';
+export declare function injectOne(target: ConsumerPackage, scope: Scope, flags: DefaultFlags, originCwd: string): Promise<void>;

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

@@ -0,0 +1,46 @@
+import 'node:crypto';
+import 'node:fs/promises';
+import 'node:path';
+import { injectDocs } from '../../../core/injectDocs/injectDocs.mjs';
+import 'node:os';
+import 'node:fs';
+import '@inquirer/prompts';
+import 'picocolors';
+import { confirmForceAsync } from '../../../prompts/confirmForce.mjs';
+import { startHeartbeat } from '../../../utils/heartbeat.mjs';
+import { logger } from '../../../utils/logger.mjs';
+
+async function injectOne(target, scope, flags, originCwd) {
+    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.`);
+        return;
+    }
+    logger.heading(`${target.name}@${target.version}`);
+    const stopHeartbeat = startHeartbeat({
+        label: `injecting ${target.name}`,
+    });
+    try {
+        const report = await injectDocs({
+            packageName: target.name,
+            packageVersion: target.version,
+            packageRoot: target.packageRoot,
+            assetRoot: target.assetRoot,
+            scope,
+            originCwd,
+            dryRun: flags.dryRun ?? false,
+            force: flags.force ?? false,
+            confirmForce: async (plan) => {
+                const diverged = plan.actions.filter((a) => a.kind === 'warn-diverged');
+                const orphans = plan.actions.filter((a) => a.kind === 'warn-orphan');
+                return confirmForceAsync(diverged.length, orphans.length, [...diverged, ...orphans].map((a) => a.relPath).slice(0, 3));
+            },
+        });
+        if (report.exitCode !== 0)
+            process.exit(report.exitCode);
+    }
+    finally {
+        stopHeartbeat();
+    }
+}
+
+export { injectOne };

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/runInject.cjs

@@ -0,0 +1,36 @@
+'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, options) {
+    if (!options.packageRoot ||
+        !options.packageName ||
+        !options.packageVersion ||
+        !options.assetPath) {
+        logger.logger.error('runCli requires { packageRoot, packageName, packageVersion, assetPath }.');
+        process.exit(2);
+    }
+    if (!node_path.isAbsolute(options.packageRoot)) {
+        logger.logger.error(`packageRoot must be an absolute path; received: ${options.packageRoot}`);
+        process.exit(2);
+    }
+    const assetRoot = node_path.resolve(options.packageRoot, options.assetPath);
+    const hashesPath = node_path.join(options.packageRoot, 'dist', 'claude-hashes.json');
+    const hashesPresent = await promises.stat(hashesPath).then(() => true, () => false);
+    const target = {
+        name: options.packageName,
+        version: options.packageVersion,
+        packageRoot: options.packageRoot,
+        assetRoot,
+        hashesPresent,
+    };
+    const originCwd = flags.root ?? process.cwd();
+    const scope = await resolveScopeFlag.resolveScopeFlag(flags.scope);
+    await injectOne.injectOne(target, scope, flags, originCwd);
+}
+
+exports.runInject = runInject;

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

@@ -0,0 +1,2 @@
+import type { DefaultFlags, RunCliOptions } from '../type.js';
+export declare function runInject(flags: DefaultFlags, options: RunCliOptions): Promise<void>;

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

@@ -0,0 +1,34 @@
+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, options) {
+    if (!options.packageRoot ||
+        !options.packageName ||
+        !options.packageVersion ||
+        !options.assetPath) {
+        logger.error('runCli requires { packageRoot, packageName, packageVersion, assetPath }.');
+        process.exit(2);
+    }
+    if (!isAbsolute(options.packageRoot)) {
+        logger.error(`packageRoot must be an absolute path; received: ${options.packageRoot}`);
+        process.exit(2);
+    }
+    const assetRoot = resolve(options.packageRoot, options.assetPath);
+    const hashesPath = join(options.packageRoot, 'dist', 'claude-hashes.json');
+    const hashesPresent = await stat(hashesPath).then(() => true, () => false);
+    const target = {
+        name: options.packageName,
+        version: options.packageVersion,
+        packageRoot: options.packageRoot,
+        assetRoot,
+        hashesPresent,
+    };
+    const originCwd = flags.root ?? process.cwd();
+    const scope = await resolveScopeFlag(flags.scope);
+    await injectOne(target, scope, flags, originCwd);
+}
+
+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 };