@untitled-devs/wasla 0.1.2 → 1.0.0

package/README.md

@@ -13,6 +13,9 @@
 
 [![MIT License](https://img.shields.io/badge/license-MIT-00C896?style=flat-square)](LICENSE)
 [![GitHub](https://img.shields.io/badge/github-The--Untitled--Org-00C896?style=flat-square&logo=github)](https://github.com/The-Untitled-Org/wasla-genie)
+[![npm version](https://img.shields.io/npm/v/@untitled-devs/wasla?style=flat-square&logo=npm)](https://www.npmjs.com/package/@untitled-devs/wasla)
+[![npm downloads](https://img.shields.io/npm/dm/@untitled-devs/wasla?style=flat-square&logo=npm)](https://www.npmjs.com/package/@untitled-devs/wasla)
+[![GitHub Release](https://img.shields.io/github/v/release/The-Untitled-Org/wasla-genie?style=flat-square)](https://github.com/The-Untitled-Org/wasla-genie/releases)
 [![CI & Docs Deployment](https://github.com/The-Untitled-Org/wasla-genie/actions/workflows/ci-docs.yml/badge.svg)](https://github.com/The-Untitled-Org/wasla-genie/actions/workflows/ci-docs.yml)
 [![Coverage](https://codecov.io/gh/The-Untitled-Org/wasla-genie/branch/main/graph/badge.svg)](https://codecov.io/gh/The-Untitled-Org/wasla-genie)
 [![Status](https://img.shields.io/badge/status-alpha-orange?style=flat-square)]()
@@ -121,15 +124,18 @@ The same pattern applies across every asset type:
 WaslaGenie is cross-platform via `npx` — no global install required:
 
 ```bash
+npx @untitled-devs/wasla config --scope workspace
 npx @untitled-devs/wasla sync
 ```
 
-This runs the CLI directly. It does not register helper skills inside Claude, Gemini, or other tools.
+Choose `workspace` or `user` once before running operational commands. This runs the CLI directly.
+It does not register helper skills inside Claude, Gemini, or other tools.
 
 **Or install globally:**
 
 ```bash
 npm install -g @untitled-devs/wasla
+waslagenie config --scope workspace
 waslagenie sync
 ```
 
@@ -178,10 +184,10 @@ npx @untitled-devs/wasla visualizer
 ### You (developing this repo)
 
 ```bash
-# Build + run sync (workspace scope) using your local source
+# Build + run sync using your configured scope
 npm run sync
 
-# Build + run watch (workspace scope)
+# Build + run watch using your configured scope
 npm run watch
 ```
 
@@ -257,14 +263,18 @@ No restart. No manual trigger. The moment something changes — it's everywhere.
 
 ### Scope — workspace or user level
 
+Choose the active scope before running sync, watch, status, or the visualizer:
+
 ```bash
-# Sync only within current project workspace
-waslagenie sync --scope workspace
+# Use the current project workspace registry
+waslagenie config --scope workspace
 
-# Sync across your entire user space (default)
-waslagenie sync --scope user
+# Use the user-level registry across projects
+waslagenie config --scope user
 ```
 
+All other commands use the saved scope automatically. They do not accept `--scope`.
+
 ---
 
 ### Status — see everything and where it lives
@@ -312,22 +322,19 @@ review-pr          command    openclaw    claude ✔  gemini ✔  codex ✔  her
 
 ## 🗃️ Registry Storage
 
-WaslaGenie keeps its own state separately from all orchestrators. You choose the scope at install time:
+WaslaGenie keeps its own state separately from all orchestrators. You choose the active scope explicitly before the first sync:
 
-**User-level** (default — available across all your projects):
+**User-level** (available across all your projects):
 ```
 ~/.waslagenie/
-├── registry.json     ← every discovered asset + origin tool + stub locations
-├── stubs/            ← log of every stub written and when
-└── config.json       ← your scope and preferences
+├── registry.json     ← user-scope assets and stub locations
+└── config.json       ← active scope preference
 ```
 
 **Workspace-level** (scoped to current project only):
 ```
 .waslagenie/
-├── registry.json
-├── stubs/
-└── config.json
+└── registry.json     ← workspace-scope assets and stub locations
 ```
 
 Switch anytime:
@@ -374,22 +381,17 @@ Nothing is forced. Centralization is a convenience, not a requirement.
 
 ```
 wasla-genie/
-├── src/
-│   ├── cli/              # CLI entry point and commands
-│   ├── scanner/          # Scans known tool config directories
-│   ├── registry/         # Builds and maintains the asset registry
-│   ├── syncer/           # Writes and tracks stub files
-│   ├── watcher/          # Daemon / filesystem watcher
-│   └── adapters/         # Per-tool directory knowledge + stub format
-│       ├── claude.js
-│       ├── gemini.js
-│       ├── codex.js
-│       ├── openclaw.js
-│       └── hermes.js
+├── apps/
+│   ├── cli/src/          # CLI commands and visualizer server
+│   └── visualizer/src/   # React visualizer
+├── packages/
+│   ├── adapters/src/     # Per-tool directory knowledge + stub format
+│   ├── core/src/         # Registry, scanner, and shared types
+│   ├── shared/src/       # Shared config, filesystem, and path helpers
+│   └── sync/src/         # Sync orchestration and filesystem watcher
+├── tests/
+├── scripts/
 ├── docs/
-│   ├── how-stubs-work.md
-│   ├── adapters.md
-│   └── roadmap.md
 ├── package.json
 └── README.md
 ```
@@ -414,11 +416,13 @@ Nothing is ever duplicated.
 git clone https://github.com/The-Untitled-Org/wasla-genie
 cd wasla-genie
 npm install
+npm run visualizer:install
 npm run dev
 ```
 
 - [Contributing Guide](CONTRIBUTING.md)
 - [Architecture Docs](docs/docs/architecture/index.md)
+- [Release Guide](RELEASING.md)
 
 ---
 

package/dist/{utils → apps/cli/src}/cli-output.d.ts

@@ -1,8 +1,12 @@
+import type { Asset } from '#core/types.js';
+export declare function banner(): void;
 export declare function success(message: string): void;
 export declare function error(message: string): void;
 export declare function info(message: string): void;
 export declare function warning(message: string): void;
 export declare function highlight(message: string): void;
+export declare function metric(label: string, value: string | number): void;
+export declare function assetList(assets: Asset[], includeModifiedAt?: boolean, activeProviders?: string[]): void;
 export declare function step(title: string): void;
 export declare function section(title: string): void;
 export declare function table(rows: string[][], columnWidths?: number[]): void;

package/dist/apps/cli/src/cli-output.js

@@ -0,0 +1,98 @@
+const ansi = {
+    reset: '\u001b[0m',
+    bold: '\u001b[1m',
+    cyan: '\u001b[36m',
+    blue: '\u001b[34m',
+    green: '\u001b[32m',
+    red: '\u001b[31m',
+    yellow: '\u001b[33m',
+    magenta: '\u001b[35m',
+};
+function color(text, ...codes) {
+    return `${codes.join('')}${text}${ansi.reset}`;
+}
+export function banner() {
+    console.log(color(`
+ __        __         _        ____            _
+ \\ \\      / /_ _ ___| | __ _ / ___| ___ _ __ (_) ___
+  \\ \\ /\\ / / _\` / __| |/ _\` | |  _ / _ \\ '_ \\| |/ _ \\
+   \\ V  V / (_| \\__ \\ | (_| | |_| |  __/ | | | |  __/
+    \\_/\\_/ \\__,_|___/_|\\__,_|\\____|\\___|_| |_|_|\\___|
+`, ansi.bold, ansi.cyan));
+}
+export function success(message) {
+    console.log(color(`✔  ${message}`, ansi.green));
+}
+export function error(message) {
+    console.error(color(`✗  ${message}`, ansi.red));
+}
+export function info(message) {
+    console.log(color(`ℹ  ${message}`, ansi.blue));
+}
+export function warning(message) {
+    console.log(color(`⚠  ${message}`, ansi.yellow));
+}
+export function highlight(message) {
+    console.log(color(`✨ ${message}`, ansi.magenta, ansi.bold));
+}
+export function metric(label, value) {
+    console.log(`  ${color(label.padEnd(20), ansi.blue)} ${color(String(value), ansi.bold)}`);
+}
+export function assetList(assets, includeModifiedAt = false, activeProviders) {
+    const assetTypes = ['agent', 'skill', 'mcp', 'context'];
+    const headings = {
+        agent: 'AGENTS',
+        skill: 'SKILLS',
+        mcp: 'MCP SERVERS',
+        context: 'CONTEXT FILES',
+    };
+    const activeProviderSet = activeProviders ? new Set(activeProviders) : null;
+    for (const type of assetTypes) {
+        const typedAssets = assets
+            .filter((asset) => asset.type === type)
+            .sort((a, b) => a.name.localeCompare(b.name));
+        if (typedAssets.length === 0)
+            continue;
+        console.log(color(`  ${headings[type]} (${typedAssets.length})`, ansi.cyan, ansi.bold));
+        for (const asset of typedAssets) {
+            const providers = [...new Set(asset.stubs.map((stub) => stub.tool))]
+                .sort()
+                .filter((provider) => !activeProviderSet || activeProviderSet.has(provider));
+            console.log(`  ${color('•', ansi.green)} ${color(asset.name, ansi.bold)}`);
+            console.log(`    ${color('Mirrors:', ansi.blue)} ${providers.join(', ') || 'none'}`);
+            if (includeModifiedAt) {
+                console.log(`    ${color('Updated:', ansi.blue)} ${new Date(asset.last_modified_at).toLocaleString()}`);
+            }
+        }
+        spacer();
+    }
+}
+export function step(title) {
+    console.log(`\n${title}`);
+}
+export function section(title) {
+    console.log(color(`\n🔍 ${title}`, ansi.blue, ansi.bold));
+}
+export function table(rows, columnWidths) {
+    if (rows.length === 0)
+        return;
+    // Calculate column widths if not provided
+    const widths = columnWidths ||
+        rows[0].map((_, i) => {
+            return Math.max(...rows.map((row) => (row[i] || '').length));
+        });
+    rows.forEach((row) => {
+        const line = row.map((cell, i) => (cell || '').padEnd(widths[i] || 10)).join('  ');
+        console.log(line);
+    });
+}
+export function spacer() {
+    console.log('');
+}
+export function bulletPoint(text, indent = 0) {
+    const spaces = '  '.repeat(indent);
+    console.log(`${spaces}• ${text}`);
+}
+export function code(text) {
+    return `\`${text}\``;
+}

package/dist/{cli → apps/cli/src}/commands/config.d.ts

@@ -2,5 +2,5 @@ interface ConfigOptions {
     scope?: string;
     show?: boolean;
 }
-export declare function configCommand(options: ConfigOptions): Promise<void>;
+export declare function configCommand(options: ConfigOptions): Promise<boolean>;
 export {};

package/dist/apps/cli/src/commands/config.js

@@ -0,0 +1,62 @@
+import { section, success, error, spacer, info } from '../cli-output.js';
+import prompts from 'prompts';
+import { getConfigPath, getConfiguredRegistryPath, readConfiguredScope, writeConfiguredScope, } from '#shared/config.js';
+export async function configCommand(options) {
+    try {
+        const currentScope = await readConfiguredScope();
+        // Show current config
+        if (options.show) {
+            section('Current Configuration');
+            spacer();
+            showConfig(currentScope);
+            spacer();
+            return true;
+        }
+        // Change scope if requested
+        if (options.scope) {
+            const newScope = options.scope;
+            if (newScope !== 'user' && newScope !== 'workspace') {
+                error('Invalid scope. Use: user or workspace');
+                process.exit(1);
+            }
+            await saveScope(newScope);
+            return true;
+        }
+        section('Configure Scope');
+        spacer();
+        const response = await prompts({
+            type: 'select',
+            name: 'scope',
+            message: 'Where should WaslaGenie store and sync assets?',
+            choices: [
+                { title: 'Workspace - current project only', value: 'workspace' },
+                { title: 'User - available across all projects', value: 'user' },
+            ],
+            initial: currentScope === 'user' ? 1 : 0,
+        });
+        const scope = response.scope;
+        if (!scope) {
+            info('Configuration cancelled');
+            return false;
+        }
+        await saveScope(scope);
+        return true;
+    }
+    catch (err) {
+        error(`Config failed: ${err}`);
+        process.exit(1);
+    }
+}
+async function saveScope(scope) {
+    await writeConfiguredScope(scope);
+    success(`Scope changed to: ${scope}`);
+    info(`Config: ${getConfigPath()}`);
+    info(`Registry: ${getConfiguredRegistryPath(scope)}`);
+    spacer();
+}
+function showConfig(scope) {
+    info(`Scope: ${scope ?? 'not configured'}`);
+    info(`Config: ${getConfigPath()}`);
+    if (scope)
+        info(`Registry: ${getConfiguredRegistryPath(scope)}`);
+}

package/dist/{cli → apps/cli/src}/commands/install.js

@@ -1,13 +1,18 @@
-import { section, success, error, highlight, spacer } from '../../utils/cli-output.js';
-import { getRegistryDir } from '../../utils/paths.js';
-import { ensureDir } from '../../utils/fs.js';
+import { section, success, error, highlight, spacer } from '../cli-output.js';
+import { readConfiguredScope } from '#shared/config.js';
 export async function installCommand() {
     try {
         section('Preparing WaslaGenie CLI...');
         spacer();
-        // Ensure registry directory exists
-        await ensureDir(getRegistryDir('user'));
-        success('Registry directory ready');
+        const scope = await readConfiguredScope();
+        if (scope) {
+            success(`Scope configured: ${scope}`);
+        }
+        else {
+            console.log('Choose a scope before running sync:');
+            console.log('  waslagenie config --scope user');
+            console.log('  waslagenie config --scope workspace');
+        }
         spacer();
         highlight('CLI setup complete!');
         console.log('');

package/dist/{cli → apps/cli/src}/commands/register.js

@@ -1,12 +1,14 @@
-import { getInstalledAdapters } from '../../adapters/factory.js';
-import { section, success, error, warning, highlight, spacer } from '../../utils/cli-output.js';
-import { getRegistryDir } from '../../utils/paths.js';
-import { ensureDir } from '../../utils/fs.js';
+import { getInstalledAdapters } from '#adapters/factory.js';
+import { section, success, error, warning, highlight, spacer } from '../cli-output.js';
+import { getRegistryDir } from '#shared/paths.js';
+import { ensureDir } from '#shared/fs.js';
+import { requireConfiguredScope } from '#shared/config.js';
 export async function registerCommand(options = {}) {
     try {
         section('Detecting installed orchestrators...');
         spacer();
-        const adapters = await getInstalledAdapters();
+        const scope = await requireConfiguredScope();
+        const adapters = await getInstalledAdapters(scope);
         if (adapters.length === 0) {
             error('No supported orchestrators found');
             warning('Please install Claude Code, Gemini CLI, or OpenCode first');
@@ -35,7 +37,7 @@ export async function registerCommand(options = {}) {
         spacer();
         section('Registering WaslaGenie helper skills...');
         spacer();
-        await ensureDir(getRegistryDir('user'));
+        await ensureDir(getRegistryDir(scope));
         for (const adapter of targets) {
             try {
                 await adapter.installSkill();

package/dist/apps/cli/src/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(): Promise<void>;

package/dist/apps/cli/src/commands/status.js

@@ -0,0 +1,39 @@
+import { RegistryManager } from '#core/registry.js';
+import { Scanner } from '#sync/scanner.js';
+import { assetList, section, error, info, metric, spacer } from '../cli-output.js';
+import { fileExists } from '#shared/fs.js';
+import { getRegistryPath } from '#shared/paths.js';
+import { requireConfiguredScope } from '#shared/config.js';
+export async function statusCommand() {
+    try {
+        const scope = await requireConfiguredScope();
+        const registryPath = getRegistryPath(scope);
+        if (!(await fileExists(registryPath))) {
+            error('Registry not found. Run: waslagenie sync');
+            process.exit(1);
+        }
+        const registry = new RegistryManager(scope);
+        await registry.load();
+        const registryData = registry.get();
+        const installedTools = await new Scanner(scope).detectInstalledTools();
+        section('Registry status');
+        info(`Scope: ${scope}`);
+        info(`Registry: ${registryPath}`);
+        spacer();
+        metric('Assets', registryData.assets.length);
+        metric('Conflicts', registryData.conflicts.length);
+        if (registryData.assets.length === 0) {
+            spacer();
+            section('No assets synced yet');
+            spacer();
+            return;
+        }
+        section('Synced assets');
+        spacer();
+        assetList(registryData.assets, true, installedTools);
+    }
+    catch (err) {
+        error(`Status check failed: ${err}`);
+        process.exit(1);
+    }
+}

package/dist/{cli → apps/cli/src}/commands/sync-to.d.ts

@@ -1,5 +1,4 @@
 interface SyncToOptions {
-    scope?: string;
     from?: string;
     to?: string;
 }

package/dist/{cli → apps/cli/src}/commands/sync-to.js

@@ -1,15 +1,16 @@
-import { RegistryManager } from '../../core/registry.js';
-import { Scanner } from '../../core/scanner.js';
-import { Syncer } from '../../syncer/index.js';
-import { section, error, highlight, spacer } from '../../utils/cli-output.js';
+import { RegistryManager } from '#core/registry.js';
+import { Scanner } from '#sync/scanner.js';
+import { Syncer } from '#sync/index.js';
+import { section, error, highlight, spacer } from '../cli-output.js';
+import { requireConfiguredScope } from '#shared/config.js';
 export async function syncToCommand(options) {
     try {
-        const scope = (options.scope || 'workspace');
+        const scope = await requireConfiguredScope();
         const from = options.from;
         const to = options.to;
         if (!from || !to) {
             error('Error: --from and --to are required');
-            console.log('Usage: waslagenie sync-to --from <source> --to <target> [--scope workspace|user]');
+            console.log('Usage: waslagenie sync-to --from <source> --to <target>');
             console.log('Example: waslagenie sync-to --from gemini --to claude');
             process.exit(1);
         }

package/dist/apps/cli/src/commands/sync.d.ts

@@ -0,0 +1,5 @@
+interface SyncOptions {
+    promptForScope?: boolean;
+}
+export declare function syncCommand(options?: SyncOptions): Promise<void>;
+export {};

package/dist/apps/cli/src/commands/sync.js

@@ -0,0 +1,49 @@
+import { RegistryManager } from '#core/registry.js';
+import { Scanner } from '#sync/scanner.js';
+import { Syncer } from '#sync/index.js';
+import { assetList, bulletPoint, section, error, highlight, info, metric, spacer, } from '../cli-output.js';
+import { getConfiguredRegistryPath, requireConfiguredScope } from '#shared/config.js';
+import { configCommand } from './config.js';
+export async function syncCommand(options = {}) {
+    try {
+        if (options.promptForScope !== false && !(await configCommand({}))) {
+            return;
+        }
+        const scope = await requireConfiguredScope();
+        section('Syncing assets');
+        info(`Scope: ${scope}`);
+        info(`Registry: ${getConfiguredRegistryPath(scope)}`);
+        spacer();
+        section('Scanning providers');
+        const registry = new RegistryManager(scope);
+        await registry.load();
+        const scanner = new Scanner(scope);
+        const installedTools = await scanner.detectInstalledTools();
+        info(`${installedTools.length} providers detected`);
+        for (const tool of installedTools) {
+            bulletPoint(tool, 1);
+        }
+        spacer();
+        const syncer = new Syncer(registry, scanner, scope);
+        const result = await syncer.sync(false);
+        spacer();
+        highlight('Sync complete');
+        spacer();
+        metric('Assets discovered', result.assetsDiscovered);
+        metric('Stubs written', result.stubsWritten);
+        metric('Stubs deleted', result.stubsDeleted);
+        spacer();
+        if (registry.get().assets.length === 0) {
+            info('No assets discovered');
+        }
+        else {
+            section('Discovered assets');
+            spacer();
+            assetList(registry.get().assets, false, installedTools);
+        }
+    }
+    catch (err) {
+        error(`Sync failed: ${err}`);
+        process.exit(1);
+    }
+}

package/dist/apps/cli/src/commands/watch.d.ts

@@ -0,0 +1 @@
+export declare function watchCommand(): Promise<void>;

package/dist/{cli → apps/cli/src}/commands/watch.js

@@ -1,12 +1,13 @@
 import chokidar from 'chokidar';
-import { RegistryManager } from '../../core/registry.js';
-import { Scanner } from '../../core/scanner.js';
-import { Syncer } from '../../syncer/index.js';
-import { getAllAdapters } from '../../adapters/factory.js';
-import { section, success, error, info, spacer } from '../../utils/cli-output.js';
-export async function watchCommand(options) {
+import { RegistryManager } from '#core/registry.js';
+import { Scanner } from '#sync/scanner.js';
+import { Syncer } from '#sync/index.js';
+import { getAllAdapters } from '#adapters/factory.js';
+import { section, success, error, info, spacer } from '../cli-output.js';
+import { requireConfiguredScope } from '#shared/config.js';
+export async function watchCommand() {
     try {
-        const scope = (options.scope || 'workspace');
+        const scope = await requireConfiguredScope();
         section('Watching for changes...');
         spacer();
         const registry = new RegistryManager(scope);

package/dist/{cli → apps/cli/src}/index.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { installCommand } from './commands/install.js';
 import { registerCommand } from './commands/register.js';
 import { syncCommand } from './commands/sync.js';
@@ -7,52 +10,59 @@ import { syncToCommand } from './commands/sync-to.js';
 import { statusCommand } from './commands/status.js';
 import { configCommand } from './commands/config.js';
 import { watchCommand } from './commands/watch.js';
-import { visualizerCommand } from './commands/visualizer.js';
+import { visualizerCommand } from './server/visualizer-server.js';
+import { banner } from './cli-output.js';
 const program = new Command();
+function readPackageVersion(moduleUrl) {
+    let directory = dirname(fileURLToPath(moduleUrl));
+    while (true) {
+        const packagePath = join(directory, 'package.json');
+        if (existsSync(packagePath)) {
+            return JSON.parse(readFileSync(packagePath, 'utf-8')).version;
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw new Error('Cannot find package.json');
+        directory = parent;
+    }
+}
 program
     .name('waslagenie')
     .description('Universal synchronization layer for AI agent orchestrators')
-    .version('0.1.0');
+    .version(readPackageVersion(import.meta.url));
 program.addCommand(new Command('install').description('Prepare WaslaGenie CLI state').action(installCommand));
 program.addCommand(new Command('register')
     .option('--to <targets>', 'Target provider(s), comma-separated. Example: claude,gemini')
     .description('Register WaslaGenie helper skills inside installed AI tools')
     .action((options) => registerCommand(options)));
 program.addCommand(new Command('sync')
-    .option('--scope <scope>', 'user or workspace', 'workspace')
     .description('Scan and sync agents/MCPs across tools')
-    .action((options) => syncCommand(options)));
+    .action(() => syncCommand()));
 program.addCommand(new Command('sync-to')
     .option('--from <source>', 'Source tool (gemini, claude, etc.)')
     .option('--to <targets>', 'Target tool(s), comma-separated')
-    .option('--scope <scope>', 'user or workspace', 'workspace')
     .description('Sync agents/MCPs from one tool to specific target(s)')
     .action((options) => syncToCommand(options)));
 program.addCommand(new Command('status')
-    .option('--scope <scope>', 'user or workspace', 'workspace')
     .description('Show all discovered assets and their sync state')
-    .action((options) => statusCommand(options)));
+    .action(() => statusCommand()));
 program.addCommand(new Command('config')
     .option('--scope <scope>', 'Set scope to user or workspace')
     .option('--show', 'Show current config')
     .description('Configure WaslaGenie settings')
-    .action((options) => configCommand(options)));
-program.addCommand(new Command('watch')
-    .option('--scope <scope>', 'user or workspace', 'workspace')
-    .description('Watch for changes and auto-sync')
-    .action((options) => watchCommand(options)));
+    .action(async (options) => {
+    await configCommand(options);
+}));
+program.addCommand(new Command('watch').description('Watch for changes and auto-sync').action(() => watchCommand()));
 program.addCommand(new Command('visualizer')
-    .option('--scope <scope>', 'user or workspace', 'workspace')
-    .option('--host <host>', 'Host to bind', '127.0.0.1')
     .option('--port <port>', 'Port to bind', '4072')
     .option('--no-open', 'Do not open browser automatically')
     .description('Open interactive sync visualizer with built-in backend')
     .action((options) => visualizerCommand(options)));
 program.addCommand(new Command('ui')
-    .option('--scope <scope>', 'user or workspace', 'workspace')
-    .option('--host <host>', 'Host to bind', '127.0.0.1')
     .option('--port <port>', 'Port to bind', '4072')
     .option('--no-open', 'Do not open browser automatically')
     .description('Alias for `visualizer`')
     .action((options) => visualizerCommand(options)));
+banner();
 program.parse(process.argv);

package/dist/{cli/commands/visualizer.d.ts → apps/cli/src/server/visualizer-server.d.ts}

@@ -1,8 +1,6 @@
 export declare function resolveVisualizerDist(moduleUrl: string): string;
 interface VisualizerOptions {
-    scope?: string;
     port?: string;
-    host?: string;
     noOpen?: boolean;
 }
 export declare const PROVIDER_ICONS: Record<string, string>;