@slats/claude-assets-sync 0.1.4 → 0.3.0

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

package/dist/index.cjs

@@ -1,14 +1,20 @@
 'use strict';
 
-var sync = require('./core/sync.cjs');
-var cli = require('./core/cli.cjs');
-var migration = require('./core/migration.cjs');
+var runCli = require('./commands/runCli/runCli.cjs');
+require('node:crypto');
+require('node:fs/promises');
+var hashManifest = require('./core/hashManifest/hashManifest.cjs');
+var injectDocs = require('./core/injectDocs/injectDocs.cjs');
+require('node:path');
+var scope = require('./core/scope/scope.cjs');
 
 
 
-exports.syncPackage = sync.syncPackage;
-exports.syncPackages = sync.syncPackages;
-exports.createProgram = cli.createProgram;
-exports.run = cli.run;
-exports.migrateToFlat = migration.migrateToFlat;
-exports.needsMigration = migration.needsMigration;
+exports.runCli = runCli.runCli;
+exports.HASH_MANIFEST_FILENAME = hashManifest.HASH_MANIFEST_FILENAME;
+exports.computeNamespacePrefixes = hashManifest.computeNamespacePrefixes;
+exports.readHashManifest = hashManifest.readHashManifest;
+exports.injectDocs = injectDocs.injectDocs;
+exports.isInteractive = scope.isInteractive;
+exports.isValidScope = scope.isValidScope;
+exports.resolveScope = scope.resolveScope;

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-export { syncPackage, syncPackages } from './core/sync.js';
-export { createProgram, run } from './core/cli.js';
-export { migrateToFlat, needsMigration } from './core/migration.js';
-export type { MigrationResult } from './core/migration.js';
-export type { AssetType, CliOptions, ClaudeConfig, GitHubRepoInfo, PackageInfo, SyncMeta, SyncResult, UnifiedSyncMeta, PackageSyncInfo, FileMapping, } from './utils/types.js';
+export { runCli } from './commands/index.js';
+export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, injectDocs, isInteractive, isValidScope, readHashManifest, resolveScope, type HashManifest, type InjectOptions, type InjectReport, type Scope, type ScopeResolution, } from './core/index.js';
+export type { AssetType } from './utils/types.js';

package/dist/index.mjs

@@ -1,3 +1,7 @@
-export { syncPackage, syncPackages } from './core/sync.mjs';
-export { createProgram, run } from './core/cli.mjs';
-export { migrateToFlat, needsMigration } from './core/migration.mjs';
+export { runCli } from './commands/runCli/runCli.mjs';
+import 'node:crypto';
+import 'node:fs/promises';
+export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, readHashManifest } from './core/hashManifest/hashManifest.mjs';
+export { injectDocs } from './core/injectDocs/injectDocs.mjs';
+import 'node:path';
+export { isInteractive, isValidScope, resolveScope } from './core/scope/scope.mjs';

package/dist/prompts/confirmForce.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var prompts = require('@inquirer/prompts');
+var pc = require('picocolors');
+
+async function confirmForceAsync(divergedCount, orphanCount, relPaths) {
+    const extra = Math.max(0, divergedCount + orphanCount - relPaths.length);
+    const divergedPart = pc.red(pc.bold(`${divergedCount} diverged file(s)`));
+    const orphanPart = orphanCount > 0
+        ? ` and ${pc.red(pc.bold(`delete ${orphanCount} orphan(s)`))}`
+        : '';
+    process.stderr.write(`${pc.yellow(pc.bold('!'))} This will overwrite ${divergedPart}${orphanPart}:\n`);
+    for (const p of relPaths) {
+        process.stderr.write(`  ${pc.dim('-')} ${p}\n`);
+    }
+    if (extra > 0) {
+        process.stderr.write(`  ${pc.dim(`... and ${extra} more`)}\n`);
+    }
+    process.stderr.write('\n');
+    const answer = await prompts.confirm({
+        message: pc.bold('Do you have these in git? Proceed?'),
+        default: false,
+    });
+    return answer;
+}
+
+exports.confirmForceAsync = confirmForceAsync;

package/dist/prompts/confirmForce.d.ts

@@ -0,0 +1 @@
+export declare function confirmForceAsync(divergedCount: number, orphanCount: number, relPaths: string[]): Promise<boolean>;

package/dist/prompts/confirmForce.mjs

@@ -0,0 +1,25 @@
+import { confirm } from '@inquirer/prompts';
+import pc from 'picocolors';
+
+async function confirmForceAsync(divergedCount, orphanCount, relPaths) {
+    const extra = Math.max(0, divergedCount + orphanCount - relPaths.length);
+    const divergedPart = pc.red(pc.bold(`${divergedCount} diverged file(s)`));
+    const orphanPart = orphanCount > 0
+        ? ` and ${pc.red(pc.bold(`delete ${orphanCount} orphan(s)`))}`
+        : '';
+    process.stderr.write(`${pc.yellow(pc.bold('!'))} This will overwrite ${divergedPart}${orphanPart}:\n`);
+    for (const p of relPaths) {
+        process.stderr.write(`  ${pc.dim('-')} ${p}\n`);
+    }
+    if (extra > 0) {
+        process.stderr.write(`  ${pc.dim(`... and ${extra} more`)}\n`);
+    }
+    process.stderr.write('\n');
+    const answer = await confirm({
+        message: pc.bold('Do you have these in git? Proceed?'),
+        default: false,
+    });
+    return answer;
+}
+
+export { confirmForceAsync };

package/dist/prompts/index.d.ts

@@ -0,0 +1,2 @@
+export { selectScopeAsync } from './selectScope.js';
+export { confirmForceAsync } from './confirmForce.js';