@slats/claude-assets-sync 0.1.0 → 0.1.1

package/dist/commands/add.cjs

@@ -3,10 +3,34 @@
 var ink = require('ink');
 var React = require('react');
 var AddCommand = require('../components/add/AddCommand.cjs');
+var BulkAddView = require('../components/add/BulkAddView.cjs');
 var sync = require('../core/sync.cjs');
 
 async function runAddCommand(options, cwd) {
     const workingDir = process.cwd();
+    if (options.pattern) {
+        try {
+            new RegExp(options.pattern);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Invalid regex pattern "${options.pattern}": ${msg}`);
+        }
+        const { waitUntilExit } = ink.render(React.createElement(BulkAddView.BulkAddView, {
+            pattern: options.pattern,
+            cwd: workingDir,
+            local: options.local ?? false,
+            ref: options.ref,
+        }));
+        await waitUntilExit();
+        return;
+    }
+    if (!options.package) {
+        console.error('Error: either --package or --pattern must be provided');
+        console.error('  Usage: claude-assets-sync add -p <name>');
+        console.error('         claude-assets-sync add --pattern <regex>');
+        process.exit(1);
+    }
     return new Promise((resolve, reject) => {
         const { waitUntilExit } = ink.render(React.createElement(AddCommand.AddCommand, {
             packageName: options.package,

package/dist/commands/add.d.ts

@@ -1,10 +1,6 @@
-export interface AddCommandOptions {
-    package: string;
-    local?: boolean;
-    ref?: string;
-}
+import type { AddCommandOptions } from '../commands/types.js';
 /**
- * Run the add command with interactive asset selection
+ * Run the add command with interactive asset selection or bulk pattern mode
  *
  * @param options - Add command options
  * @param cwd - Current working directory

package/dist/commands/add.mjs

@@ -1,10 +1,34 @@
 import { render } from 'ink';
 import React from 'react';
 import { AddCommand } from '../components/add/AddCommand.mjs';
+import { BulkAddView } from '../components/add/BulkAddView.mjs';
 import { syncPackage } from '../core/sync.mjs';
 
 async function runAddCommand(options, cwd) {
     const workingDir = process.cwd();
+    if (options.pattern) {
+        try {
+            new RegExp(options.pattern);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Invalid regex pattern "${options.pattern}": ${msg}`);
+        }
+        const { waitUntilExit } = render(React.createElement(BulkAddView, {
+            pattern: options.pattern,
+            cwd: workingDir,
+            local: options.local ?? false,
+            ref: options.ref,
+        }));
+        await waitUntilExit();
+        return;
+    }
+    if (!options.package) {
+        console.error('Error: either --package or --pattern must be provided');
+        console.error('  Usage: claude-assets-sync add -p <name>');
+        console.error('         claude-assets-sync add --pattern <regex>');
+        process.exit(1);
+    }
     return new Promise((resolve, reject) => {
         const { waitUntilExit } = render(React.createElement(AddCommand, {
             packageName: options.package,

package/dist/commands/index.d.ts

@@ -3,13 +3,12 @@
  */
 export * from './types';
 export { runSyncCommand } from './sync';
-export { runListCommand } from './list';
+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 { AddCommandOptions } from './add';
 export type { UpdateCommandOptions } from './update';
 /**
  * Command metadata for CLI help and documentation

package/dist/commands/list.cjs

@@ -46,7 +46,8 @@ const runListCommand = async (options, cwd = process.cwd()) => {
         return;
     }
     if (isTTY()) {
-        ink.render(React.createElement(ListCommand.ListCommand, { cwd: destDir }));
+        const { waitUntilExit } = ink.render(React.createElement(ListCommand.ListCommand, { cwd: destDir }));
+        await waitUntilExit();
         return;
     }
     const packages = [];
@@ -79,5 +80,15 @@ const runListCommand = async (options, cwd = process.cwd()) => {
         console.log('');
     }
 };
+function registerListCommand(program) {
+    program
+        .command('list')
+        .description('List all synced packages')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        await runListCommand({ json: opts.json });
+    });
+}
 
+exports.registerListCommand = registerListCommand;
 exports.runListCommand = runListCommand;

package/dist/commands/list.d.ts

@@ -1,6 +1,15 @@
+/**
+ * List command - list all synced packages
+ */
+import type { Command } from 'commander';
 import type { ListCommandOptions } from './types.js';
 /**
  * Run the list command
  * @param options - List command options
  */
-export declare const runListCommand: (options: ListCommandOptions, cwd?: string) => Promise<void>;
+declare const runListCommand: (options: ListCommandOptions, cwd?: string) => Promise<void>;
+/**
+ * Register the list command with the CLI program
+ */
+export declare function registerListCommand(program: Command): void;
+export { runListCommand };

package/dist/commands/list.mjs

@@ -44,7 +44,8 @@ const runListCommand = async (options, cwd = process.cwd()) => {
         return;
     }
     if (isTTY()) {
-        render(React.createElement(ListCommand, { cwd: destDir }));
+        const { waitUntilExit } = render(React.createElement(ListCommand, { cwd: destDir }));
+        await waitUntilExit();
         return;
     }
     const packages = [];
@@ -77,5 +78,14 @@ const runListCommand = async (options, cwd = process.cwd()) => {
         console.log('');
     }
 };
+function registerListCommand(program) {
+    program
+        .command('list')
+        .description('List all synced packages')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        await runListCommand({ json: opts.json });
+    });
+}
 
-export { runListCommand };
+export { registerListCommand, runListCommand };

package/dist/commands/remove.cjs

@@ -2,8 +2,10 @@
 
 var fs = require('node:fs');
 var path = require('node:path');
-var readline = require('node:readline/promises');
+var ink = require('ink');
 var pc = require('picocolors');
+var React = require('react');
+var RemoveConfirm = require('../components/remove/RemoveConfirm.cjs');
 var syncMeta = require('../core/syncMeta.cjs');
 var logger = require('../utils/logger.cjs');
 var packageName = require('../utils/packageName.cjs');
@@ -27,8 +29,36 @@ function _interopNamespaceDefault(e) {
 
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 
+function isTTY() {
+    return process.stdout.isTTY === true && process.stdin.isTTY === true;
+}
+function performRemoval(filesToRemove, meta, prefix, packageName, cwd) {
+    for (const { path: filePath } of filesToRemove) {
+        try {
+            const stat = fs__namespace.statSync(filePath);
+            if (stat.isDirectory()) {
+                fs__namespace.rmSync(filePath, { recursive: true, force: true });
+                console.log(`${pc.red('-')} ${filePath}`);
+            }
+            else {
+                fs__namespace.unlinkSync(filePath);
+                console.log(`${pc.red('-')} ${filePath}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.logger.error(`Failed to remove ${filePath}: ${error}`);
+            }
+        }
+    }
+    if (meta) {
+        delete meta.packages[prefix];
+        meta.syncedAt = new Date().toISOString();
+        syncMeta.writeUnifiedSyncMeta(cwd, meta);
+    }
+    logger.logger.success(`\nRemoved package ${packageName}`);
+}
 const runRemoveCommand = async (options, cwd = process.cwd()) => {
     const { package: packageName$1, yes, dryRun } = options;
     const prefix = packageName.packageNameToPrefix(packageName$1);
@@ -71,39 +101,27 @@ const runRemoveCommand = async (options, cwd = process.cwd()) => {
         return;
     }
     if (!yes) {
-        const rl = readline__namespace.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        const answer = await rl.question(pc.yellow('Remove these files? (y/N): '));
-        rl.close();
-        if (answer.toLowerCase() !== 'y') {
-            logger.logger.info('Cancelled.');
-            return;
-        }
-    }
-    for (const { path: filePath } of filesToRemove) {
-        try {
-            const stat = fs__namespace.statSync(filePath);
-            if (stat.isDirectory()) {
-                fs__namespace.rmSync(filePath, { recursive: true, force: true });
-                console.log(`${pc.red('-')} ${filePath}`);
-            }
-            else {
-                fs__namespace.unlinkSync(filePath);
-                console.log(`${pc.red('-')} ${filePath}`);
+        if (isTTY()) {
+            let confirmed = false;
+            const { waitUntilExit } = ink.render(React.createElement(RemoveConfirm.RemoveConfirm, {
+                packageName: packageName$1,
+                filesToRemove,
+                onConfirm: (result) => {
+                    confirmed = result;
+                },
+            }));
+            await waitUntilExit();
+            if (!confirmed) {
+                logger.logger.info('Cancelled.');
+                return;
             }
         }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                logger.logger.error(`Failed to remove ${filePath}: ${error}`);
-            }
+        else {
+            logger.logger.info('Cancelled (non-interactive terminal).');
+            return;
         }
     }
-    delete meta.packages[prefix];
-    meta.syncedAt = new Date().toISOString();
-    syncMeta.writeUnifiedSyncMeta(cwd, meta);
-    logger.logger.success(`\nRemoved package ${packageName$1}`);
+    performRemoval(filesToRemove, meta, prefix, packageName$1, cwd);
 };
 
 exports.runRemoveCommand = runRemoveCommand;

package/dist/commands/remove.mjs

@@ -1,11 +1,42 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as readline from 'node:readline/promises';
+import { render } from 'ink';
 import pc from 'picocolors';
+import React from 'react';
+import { RemoveConfirm } from '../components/remove/RemoveConfirm.mjs';
 import { readUnifiedSyncMeta, writeUnifiedSyncMeta } from '../core/syncMeta.mjs';
 import { logger } from '../utils/logger.mjs';
 import { packageNameToPrefix } from '../utils/packageName.mjs';
 
+function isTTY() {
+    return process.stdout.isTTY === true && process.stdin.isTTY === true;
+}
+function performRemoval(filesToRemove, meta, prefix, packageName, cwd) {
+    for (const { path: filePath } of filesToRemove) {
+        try {
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory()) {
+                fs.rmSync(filePath, { recursive: true, force: true });
+                console.log(`${pc.red('-')} ${filePath}`);
+            }
+            else {
+                fs.unlinkSync(filePath);
+                console.log(`${pc.red('-')} ${filePath}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.error(`Failed to remove ${filePath}: ${error}`);
+            }
+        }
+    }
+    if (meta) {
+        delete meta.packages[prefix];
+        meta.syncedAt = new Date().toISOString();
+        writeUnifiedSyncMeta(cwd, meta);
+    }
+    logger.success(`\nRemoved package ${packageName}`);
+}
 const runRemoveCommand = async (options, cwd = process.cwd()) => {
     const { package: packageName, yes, dryRun } = options;
     const prefix = packageNameToPrefix(packageName);
@@ -48,39 +79,27 @@ const runRemoveCommand = async (options, cwd = process.cwd()) => {
         return;
     }
     if (!yes) {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        const answer = await rl.question(pc.yellow('Remove these files? (y/N): '));
-        rl.close();
-        if (answer.toLowerCase() !== 'y') {
-            logger.info('Cancelled.');
-            return;
-        }
-    }
-    for (const { path: filePath } of filesToRemove) {
-        try {
-            const stat = fs.statSync(filePath);
-            if (stat.isDirectory()) {
-                fs.rmSync(filePath, { recursive: true, force: true });
-                console.log(`${pc.red('-')} ${filePath}`);
-            }
-            else {
-                fs.unlinkSync(filePath);
-                console.log(`${pc.red('-')} ${filePath}`);
+        if (isTTY()) {
+            let confirmed = false;
+            const { waitUntilExit } = render(React.createElement(RemoveConfirm, {
+                packageName,
+                filesToRemove,
+                onConfirm: (result) => {
+                    confirmed = result;
+                },
+            }));
+            await waitUntilExit();
+            if (!confirmed) {
+                logger.info('Cancelled.');
+                return;
             }
         }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                logger.error(`Failed to remove ${filePath}: ${error}`);
-            }
+        else {
+            logger.info('Cancelled (non-interactive terminal).');
+            return;
         }
     }
-    delete meta.packages[prefix];
-    meta.syncedAt = new Date().toISOString();
-    writeUnifiedSyncMeta(cwd, meta);
-    logger.success(`\nRemoved package ${packageName}`);
+    performRemoval(filesToRemove, meta, prefix, packageName, cwd);
 };
 
 export { runRemoveCommand };

package/dist/commands/types.d.ts

@@ -9,6 +9,15 @@ export interface CommandResult {
     success: boolean;
     message?: string;
 }
+/**
+ * Options for add command
+ */
+export interface AddCommandOptions {
+    package?: string;
+    pattern?: string;
+    local?: boolean;
+    ref?: string;
+}
 /**
  * Options for sync command
  */

package/dist/commands/update.cjs

@@ -9,6 +9,32 @@ var logger = require('../utils/logger.cjs');
 var _package = require('../utils/package.cjs');
 var packageName = require('../utils/packageName.cjs');
 
+async function updatePackageVersionAndSync(prefix, meta, options, cwd) {
+    const packageInfo = meta.packages[prefix];
+    if (!packageInfo) {
+        throw new Error(`Package ${prefix} not found in metadata`);
+    }
+    const packageName = packageInfo.originalName;
+    const isLocal = options.local ?? packageInfo.local ?? false;
+    const currentPkgInfo = isLocal
+        ? _package.readLocalPackageJson(packageName, cwd)
+        : _package.readPackageJson(packageName, cwd);
+    if (!currentPkgInfo) {
+        return { updatedMeta: meta, versionChanged: false };
+    }
+    const newVersion = currentPkgInfo.version;
+    const oldVersion = packageInfo.version;
+    if (newVersion === oldVersion) {
+        return { updatedMeta: meta, versionChanged: false, oldVersion, newVersion };
+    }
+    let updatedMeta = syncMeta.updatePackageVersion(meta, prefix, newVersion);
+    updatedMeta.syncedAt = new Date().toISOString();
+    {
+        const destDir = _package.findGitRoot(cwd) ?? cwd;
+        await sync.syncPackage(packageName, { force: true, dryRun: false, local: isLocal, ref: options.ref, flat: true }, cwd, packageInfo.exclusions, destDir);
+    }
+    return { updatedMeta, versionChanged: true, oldVersion, newVersion };
+}
 const runUpdateCommand = async (options, cwd = process.cwd()) => {
     const destDir = _package.findGitRoot(cwd) ?? cwd;
     const meta = syncMeta.readUnifiedSyncMeta(destDir);
@@ -180,3 +206,4 @@ const runUpdateCommand = async (options, cwd = process.cwd()) => {
 };
 
 exports.runUpdateCommand = runUpdateCommand;
+exports.updatePackageVersionAndSync = updatePackageVersionAndSync;

package/dist/commands/update.d.ts

@@ -1,3 +1,4 @@
+import type { UnifiedSyncMeta } from '../utils/types';
 export interface UpdateCommandOptions {
     package?: string;
     local?: boolean;
@@ -5,6 +6,21 @@ export interface UpdateCommandOptions {
     dryRun?: boolean;
     sync?: boolean;
 }
+export interface UpdatePackageResult {
+    updatedMeta: UnifiedSyncMeta;
+    versionChanged: boolean;
+    oldVersion?: string;
+    newVersion?: string;
+}
+/**
+ * Higher-level orchestration: read installed version, compare with meta, update if different,
+ * optionally re-sync files. Can be called from both CLI and interactive list UI.
+ */
+export declare function updatePackageVersionAndSync(prefix: string, meta: UnifiedSyncMeta, options: {
+    local?: boolean;
+    ref?: string;
+    sync?: boolean;
+}, cwd: string): Promise<UpdatePackageResult>;
 /**
  * Run the update command
  * @param options - Update command options

package/dist/commands/update.mjs

@@ -7,6 +7,32 @@ import { logger } from '../utils/logger.mjs';
 import { findGitRoot, readLocalPackageJson, readPackageJson } from '../utils/package.mjs';
 import { packageNameToPrefix } from '../utils/packageName.mjs';
 
+async function updatePackageVersionAndSync(prefix, meta, options, cwd) {
+    const packageInfo = meta.packages[prefix];
+    if (!packageInfo) {
+        throw new Error(`Package ${prefix} not found in metadata`);
+    }
+    const packageName = packageInfo.originalName;
+    const isLocal = options.local ?? packageInfo.local ?? false;
+    const currentPkgInfo = isLocal
+        ? readLocalPackageJson(packageName, cwd)
+        : readPackageJson(packageName, cwd);
+    if (!currentPkgInfo) {
+        return { updatedMeta: meta, versionChanged: false };
+    }
+    const newVersion = currentPkgInfo.version;
+    const oldVersion = packageInfo.version;
+    if (newVersion === oldVersion) {
+        return { updatedMeta: meta, versionChanged: false, oldVersion, newVersion };
+    }
+    let updatedMeta = updatePackageVersion(meta, prefix, newVersion);
+    updatedMeta.syncedAt = new Date().toISOString();
+    {
+        const destDir = findGitRoot(cwd) ?? cwd;
+        await syncPackage(packageName, { force: true, dryRun: false, local: isLocal, ref: options.ref, flat: true }, cwd, packageInfo.exclusions, destDir);
+    }
+    return { updatedMeta, versionChanged: true, oldVersion, newVersion };
+}
 const runUpdateCommand = async (options, cwd = process.cwd()) => {
     const destDir = findGitRoot(cwd) ?? cwd;
     const meta = readUnifiedSyncMeta(destDir);
@@ -177,4 +203,4 @@ const runUpdateCommand = async (options, cwd = process.cwd()) => {
     }
 };
 
-export { runUpdateCommand };
+export { runUpdateCommand, updatePackageVersionAndSync };

package/dist/components/add/BulkAddView.cjs

@@ -0,0 +1,169 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var ink = require('ink');
+var Spinner = require('ink-spinner');
+var React = require('react');
+var packageScanner = require('../../core/packageScanner.cjs');
+var sync = require('../../core/sync.cjs');
+var asyncPool = require('../../utils/asyncPool.cjs');
+var dependencies = require('../../utils/dependencies.cjs');
+var StepRunner = require('../shared/StepRunner.cjs');
+var Table = require('../shared/Table.cjs');
+
+const BulkAddView = ({ pattern, cwd, local = false, ref, }) => {
+    const [phase, setPhase] = React.useState('scanning-deps');
+    const [matches, setMatches] = React.useState([]);
+    const [scanSteps, setScanSteps] = React.useState([]);
+    const [syncSteps, setSyncSteps] = React.useState([]);
+    const [results, setResults] = React.useState([]);
+    const [errorMessage, setErrorMessage] = React.useState('');
+    React.useEffect(() => {
+        const run = async () => {
+            setPhase('scanning-deps');
+            let matched;
+            try {
+                const deps = dependencies.readProjectDependencies(cwd);
+                matched = dependencies.filterByPattern(deps, pattern);
+            }
+            catch (err) {
+                setErrorMessage(err instanceof Error ? err.message : String(err));
+                setPhase('error');
+                return;
+            }
+            setMatches(matched);
+            if (matched.length === 0) {
+                setResults([]);
+                setPhase('done');
+                return;
+            }
+            setPhase('scanning-assets');
+            const initialScanSteps = matched.map((name) => ({
+                name,
+                status: 'pending',
+            }));
+            setScanSteps(initialScanSteps);
+            const packagesWithAssets = [];
+            const scanResults = [];
+            await asyncPool.asyncPool(3, matched, async (pkgName) => {
+                setScanSteps((prev) => prev.map((s) => s.name === pkgName ? { ...s, status: 'running' } : s));
+                try {
+                    const trees = await packageScanner.scanPackageAssets(pkgName, {
+                        local,
+                        ref,
+                        cwd,
+                    });
+                    const hasAssets = trees.length > 0;
+                    if (hasAssets) {
+                        packagesWithAssets.push(pkgName);
+                        setScanSteps((prev) => prev.map((s) => s.name === pkgName
+                            ? { ...s, status: 'success', output: `${trees.length} asset type(s)` }
+                            : s));
+                    }
+                    else {
+                        scanResults.push({ name: pkgName, status: 'skipped', assetCount: 0 });
+                        setScanSteps((prev) => prev.map((s) => s.name === pkgName ? { ...s, status: 'skipped' } : s));
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    const isNoAssets = /no repository|asset path.*does not exist|not found in (local workspace|node_modules)/i.test(msg);
+                    if (isNoAssets) {
+                        scanResults.push({ name: pkgName, status: 'skipped', assetCount: 0 });
+                        setScanSteps((prev) => prev.map((s) => s.name === pkgName ? { ...s, status: 'skipped' } : s));
+                    }
+                    else {
+                        scanResults.push({ name: pkgName, status: 'error', assetCount: 0, error: msg });
+                        setScanSteps((prev) => prev.map((s) => s.name === pkgName
+                            ? { ...s, status: 'failed', error: msg }
+                            : s));
+                    }
+                }
+            });
+            if (packagesWithAssets.length === 0) {
+                setResults(scanResults);
+                setPhase('done');
+                return;
+            }
+            setPhase('syncing');
+            const initialSyncSteps = packagesWithAssets.map((name) => ({
+                name,
+                status: 'pending',
+            }));
+            setSyncSteps(initialSyncSteps);
+            await asyncPool.asyncPool(3, packagesWithAssets, async (pkgName) => {
+                setSyncSteps((prev) => prev.map((s) => s.name === pkgName ? { ...s, status: 'running' } : s));
+                try {
+                    const result = await sync.syncPackage(pkgName, {
+                        force: true,
+                        dryRun: false,
+                        local,
+                        ref,
+                        flat: true,
+                    }, cwd, undefined, undefined);
+                    if (result.success && !result.skipped) {
+                        const assetCount = Object.values(result.syncedFiles ?? {}).reduce((sum, files) => sum + files.length, 0);
+                        scanResults.push({ name: pkgName, status: 'synced', assetCount });
+                        setSyncSteps((prev) => prev.map((s) => s.name === pkgName
+                            ? { ...s, status: 'success', output: `${assetCount} file(s)` }
+                            : s));
+                    }
+                    else if (result.skipped) {
+                        scanResults.push({ name: pkgName, status: 'skipped', assetCount: 0 });
+                        setSyncSteps((prev) => prev.map((s) => s.name === pkgName ? { ...s, status: 'skipped' } : s));
+                    }
+                    else {
+                        const msg = result.reason ?? 'Sync failed';
+                        scanResults.push({ name: pkgName, status: 'error', assetCount: 0, error: msg });
+                        setSyncSteps((prev) => prev.map((s) => s.name === pkgName
+                            ? { ...s, status: 'failed', error: msg }
+                            : s));
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    scanResults.push({ name: pkgName, status: 'error', assetCount: 0, error: msg });
+                    setSyncSteps((prev) => prev.map((s) => s.name === pkgName
+                        ? { ...s, status: 'failed', error: msg }
+                        : s));
+                }
+            });
+            setResults(scanResults);
+            setPhase('done');
+        };
+        run();
+    }, []);
+    if (phase === 'scanning-deps') {
+        return (jsxRuntime.jsx(ink.Box, { children: jsxRuntime.jsxs(ink.Text, { color: "cyan", children: [jsxRuntime.jsx(Spinner, { type: "dots" }), " Scanning dependencies matching /", pattern, "/..."] }) }));
+    }
+    if (phase === 'error') {
+        return (jsxRuntime.jsx(ink.Box, { flexDirection: "column", children: jsxRuntime.jsxs(ink.Text, { color: "red", children: ["Error: ", errorMessage] }) }));
+    }
+    if (phase === 'scanning-assets') {
+        return (jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [jsxRuntime.jsx(ink.Box, { marginBottom: 1, children: jsxRuntime.jsxs(ink.Text, { children: ["Found ", jsxRuntime.jsx(ink.Text, { bold: true, children: matches.length }), " matching package(s). Scanning assets..."] }) }), jsxRuntime.jsx(StepRunner.StepRunner, { steps: scanSteps, currentStep: scanSteps.findIndex((s) => s.status === 'running'), total: scanSteps.length })] }));
+    }
+    if (phase === 'syncing') {
+        return (jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [jsxRuntime.jsx(ink.Box, { marginBottom: 1, children: jsxRuntime.jsx(ink.Text, { children: "Syncing packages..." }) }), jsxRuntime.jsx(StepRunner.StepRunner, { steps: syncSteps, currentStep: syncSteps.findIndex((s) => s.status === 'running'), total: syncSteps.length })] }));
+    }
+    if (phase === 'done') {
+        const synced = results.filter((r) => r.status === 'synced').length;
+        const skipped = results.filter((r) => r.status === 'skipped').length;
+        const errors = results.filter((r) => r.status === 'error').length;
+        if (results.length === 0) {
+            return (jsxRuntime.jsx(ink.Box, { flexDirection: "column", children: jsxRuntime.jsxs(ink.Text, { color: "yellow", children: ["No packages matched pattern /", pattern, "/"] }) }));
+        }
+        const rows = results.map((r) => {
+            const statusCell = r.status === 'synced'
+                ? '✓ synced'
+                : r.status === 'skipped'
+                    ? '⏭ skipped'
+                    : `✗ error`;
+            const assetsCell = r.status === 'synced' ? String(r.assetCount) : r.error ?? '-';
+            return [r.name, statusCell, assetsCell];
+        });
+        return (jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [jsxRuntime.jsx(Table.Table, { headers: ['Package', 'Status', 'Assets'], rows: rows }), jsxRuntime.jsx(ink.Box, { marginTop: 1, children: jsxRuntime.jsxs(ink.Text, { children: [jsxRuntime.jsxs(ink.Text, { color: "green", children: [synced, " synced"] }), jsxRuntime.jsx(ink.Text, { children: ", " }), jsxRuntime.jsxs(ink.Text, { color: "blue", children: [skipped, " skipped"] }), jsxRuntime.jsx(ink.Text, { children: ", " }), jsxRuntime.jsxs(ink.Text, { color: errors > 0 ? 'red' : 'gray', children: [errors, " errors"] })] }) })] }));
+    }
+    return null;
+};
+
+exports.BulkAddView = BulkAddView;