kynjal-cli 4.0.0 → 4.0.1

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

@@ -0,0 +1,115 @@
+/**
+ * V3 CLI Commands Index
+ * Central registry for all CLI commands
+ *
+ * NOTE: All commands are synchronously imported at module load time (lines below).
+ * The commandLoaders/loadCommand infrastructure provides an async fallback for
+ * commands looked up via getCommandAsync() but does NOT reduce startup time since
+ * all modules are already imported synchronously for the commands array and
+ * commandsByCategory exports.
+ */
+import type { Command } from '../types.js';
+export { initCommand } from './init.js';
+export { startCommand } from './start.js';
+export { statusCommand } from './status.js';
+export { taskCommand } from './task.js';
+export { sessionCommand } from './session.js';
+export { agentCommand } from './agent.js';
+export { swarmCommand } from './swarm.js';
+export { memoryCommand } from './memory.js';
+export { mcpCommand } from './mcp.js';
+export { hooksCommand } from './hooks.js';
+export { daemonCommand } from './daemon.js';
+export { doctorCommand } from './doctor.js';
+export { embeddingsCommand } from './embeddings.js';
+export { neuralCommand } from './neural.js';
+export { performanceCommand } from './performance.js';
+export { securityCommand } from './security.js';
+export { ruvectorCommand } from './ruvector/index.js';
+export { hiveMindCommand } from './hive-mind.js';
+export { guidanceCommand } from './guidance.js';
+export { applianceCommand } from './appliance.js';
+export { cleanupCommand } from './cleanup.js';
+export declare function getConfigCommand(): Promise<Command | undefined>;
+export declare function getMigrateCommand(): Promise<Command | undefined>;
+export declare function getWorkflowCommand(): Promise<Command | undefined>;
+export declare function getHiveMindCommand(): Promise<Command | undefined>;
+export declare function getProcessCommand(): Promise<Command | undefined>;
+export declare function getTaskCommand(): Promise<Command | undefined>;
+export declare function getSessionCommand(): Promise<Command | undefined>;
+export declare function getNeuralCommand(): Promise<Command | undefined>;
+export declare function getSecurityCommand(): Promise<Command | undefined>;
+export declare function getPerformanceCommand(): Promise<Command | undefined>;
+export declare function getProvidersCommand(): Promise<Command | undefined>;
+export declare function getPluginsCommand(): Promise<Command | undefined>;
+export declare function getDeploymentCommand(): Promise<Command | undefined>;
+export declare function getClaimsCommand(): Promise<Command | undefined>;
+export declare function getEmbeddingsCommand(): Promise<Command | undefined>;
+export declare function getCompletionsCommand(): Promise<Command | undefined>;
+export declare function getAnalyzeCommand(): Promise<Command | undefined>;
+export declare function getRouteCommand(): Promise<Command | undefined>;
+export declare function getProgressCommand(): Promise<Command | undefined>;
+export declare function getIssuesCommand(): Promise<Command | undefined>;
+export declare function getRuvectorCommand(): Promise<Command | undefined>;
+export declare function getGuidanceCommand(): Promise<Command | undefined>;
+export declare function getApplianceCommand(): Promise<Command | undefined>;
+export declare function getCleanupCommand(): Promise<Command | undefined>;
+/**
+ * Core commands loaded synchronously (available immediately)
+ * Advanced commands loaded on-demand for faster startup
+ */
+export declare const commands: Command[];
+/**
+ * Commands organized by category for help display
+ */
+export declare const commandsByCategory: {
+    primary: Command[];
+    advanced: Command[];
+    utility: Command[];
+    analysis: Command[];
+    management: Command[];
+};
+/**
+ * Command registry map for quick lookup
+ * Supports both sync (core commands) and async (lazy-loaded) commands
+ */
+export declare const commandRegistry: Map<string, Command>;
+/**
+ * Get command by name (sync for core commands, returns undefined for lazy commands)
+ * Use getCommandAsync for lazy-loaded commands
+ */
+export declare function getCommand(name: string): Command | undefined;
+/**
+ * Get command by name (async - supports lazy loading)
+ */
+export declare function getCommandAsync(name: string): Promise<Command | undefined>;
+/**
+ * Check if command exists (sync check for core commands)
+ */
+export declare function hasCommand(name: string): boolean;
+/**
+ * Get all command names (including aliases and lazy-loadable)
+ */
+export declare function getCommandNames(): string[];
+/**
+ * Get all unique commands (excluding aliases)
+ */
+export declare function getUniqueCommands(): Command[];
+/**
+ * Load all commands (populates lazy-loaded commands)
+ * Use this when you need all commands available synchronously
+ */
+export declare function loadAllCommands(): Promise<Command[]>;
+/**
+ * Setup commands in a CLI instance
+ */
+export declare function setupCommands(cli: {
+    command: (cmd: Command) => void;
+}): void;
+/**
+ * Setup all commands including lazy-loaded (async)
+ */
+export declare function setupAllCommands(cli: {
+    command: (cmd: Command) => void;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAyK3C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAG9C,wBAAsB,gBAAgB,iCAAoC;AAC1E,wBAAsB,iBAAiB,iCAAqC;AAC5E,wBAAsB,kBAAkB,iCAAsC;AAC9E,wBAAsB,kBAAkB,iCAAuC;AAC/E,wBAAsB,iBAAiB,iCAAqC;AAC5E,wBAAsB,cAAc,iCAAkC;AACtE,wBAAsB,iBAAiB,iCAAqC;AAC5E,wBAAsB,gBAAgB,iCAAoC;AAC1E,wBAAsB,kBAAkB,iCAAsC;AAC9E,wBAAsB,qBAAqB,iCAAyC;AACpF,wBAAsB,mBAAmB,iCAAuC;AAChF,wBAAsB,iBAAiB,iCAAqC;AAC5E,wBAAsB,oBAAoB,iCAAwC;AAClF,wBAAsB,gBAAgB,iCAAoC;AAC1E,wBAAsB,oBAAoB,iCAAwC;AAClF,wBAAsB,qBAAqB,iCAAyC;AACpF,wBAAsB,iBAAiB,iCAAqC;AAC5E,wBAAsB,eAAe,iCAAmC;AACxE,wBAAsB,kBAAkB,iCAAsC;AAC9E,wBAAsB,gBAAgB,iCAAoC;AAC1E,wBAAsB,kBAAkB,iCAAsC;AAC9E,wBAAsB,kBAAkB,iCAAsC;AAC9E,wBAAsB,mBAAmB,iCAAuC;AAChF,wBAAsB,iBAAiB,iCAAqC;AAE5E;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,OAAO,EAsB7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;CA8C9B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,sBAA6B,CAAC;AAY1D;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAE5D;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAWhF;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,EAAE,CAO1C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,EAAE,CAE7C;AAED;;;GAGG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAa1D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE;IAAE,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CAAE,GAAG,IAAI,CAI5E;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE;IAAE,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAK9F"}

package/dist/src/commands/index.js

@@ -8,148 +8,91 @@
  * all modules are already imported synchronously for the commands array and
  * commandsByCategory exports.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 /**
  * Command loaders - commands are only imported when needed
  * This reduces initial bundle parse time by ~200ms
  */
-var commandLoaders = {
+const commandLoaders = {
     // P1 Core Commands (frequently used - load first)
-    init: function () { return import('./init.js'); },
-    start: function () { return import('./start.js'); },
-    status: function () { return import('./status.js'); },
-    task: function () { return import('./task.js'); },
-    session: function () { return import('./session.js'); },
+    init: () => import('./init.js'),
+    start: () => import('./start.js'),
+    status: () => import('./status.js'),
+    task: () => import('./task.js'),
+    session: () => import('./session.js'),
     // Original Commands
-    agent: function () { return import('./agent.js'); },
-    swarm: function () { return import('./swarm.js'); },
-    memory: function () { return import('./memory.js'); },
-    mcp: function () { return import('./mcp.js'); },
-    config: function () { return import('./config.js'); },
-    migrate: function () { return import('./migrate.js'); },
-    hooks: function () { return import('./hooks.js'); },
-    workflow: function () { return import('./workflow.js'); },
-    'hive-mind': function () { return import('./hive-mind.js'); },
-    process: function () { return import('./process.js'); },
-    daemon: function () { return import('./daemon.js'); },
+    agent: () => import('./agent.js'),
+    swarm: () => import('./swarm.js'),
+    memory: () => import('./memory.js'),
+    mcp: () => import('./mcp.js'),
+    config: () => import('./config.js'),
+    migrate: () => import('./migrate.js'),
+    hooks: () => import('./hooks.js'),
+    workflow: () => import('./workflow.js'),
+    'hive-mind': () => import('./hive-mind.js'),
+    process: () => import('./process.js'),
+    daemon: () => import('./daemon.js'),
     // V3 Advanced Commands (less frequently used - lazy load)
-    neural: function () { return import('./neural.js'); },
-    security: function () { return import('./security.js'); },
-    performance: function () { return import('./performance.js'); },
-    providers: function () { return import('./providers.js'); },
-    plugins: function () { return import('./plugins.js'); },
-    deployment: function () { return import('./deployment.js'); },
-    claims: function () { return import('./claims.js'); },
-    embeddings: function () { return import('./embeddings.js'); },
+    neural: () => import('./neural.js'),
+    security: () => import('./security.js'),
+    performance: () => import('./performance.js'),
+    providers: () => import('./providers.js'),
+    plugins: () => import('./plugins.js'),
+    deployment: () => import('./deployment.js'),
+    claims: () => import('./claims.js'),
+    embeddings: () => import('./embeddings.js'),
     // P0 Commands
-    completions: function () { return import('./completions.js'); },
-    doctor: function () { return import('./doctor.js'); },
+    completions: () => import('./completions.js'),
+    doctor: () => import('./doctor.js'),
     // Analysis Commands
-    analyze: function () { return import('./analyze.js'); },
+    analyze: () => import('./analyze.js'),
     // Q-Learning Routing Commands
-    route: function () { return import('./route.js'); },
+    route: () => import('./route.js'),
     // Progress Commands
-    progress: function () { return import('./progress.js'); },
+    progress: () => import('./progress.js'),
     // Issue Claims Commands (ADR-016)
-    issues: function () { return import('./issues.js'); },
+    issues: () => import('./issues.js'),
     // Auto-update System (ADR-025)
-    update: function () { return import('./update.js'); },
+    update: () => import('./update.js'),
     // RuVector PostgreSQL Bridge
-    ruvector: function () { return import('./ruvector/index.js'); },
+    ruvector: () => import('./ruvector/index.js'),
     // Benchmark Suite (Pre-training, Neural, Memory)
-    benchmark: function () { return import('./benchmark.js'); },
+    benchmark: () => import('./benchmark.js'),
     // Guidance Control Plane
-    guidance: function () { return import('./guidance.js'); },
+    guidance: () => import('./guidance.js'),
     // RVFA Appliance Management
-    appliance: function () { return import('./appliance.js'); },
-    'appliance-advanced': function () { return import('./appliance-advanced.js'); },
-    'transfer-store': function () { return import('./transfer-store.js'); },
-    cleanup: function () { return import('./cleanup.js'); }
+    appliance: () => import('./appliance.js'),
+    'appliance-advanced': () => import('./appliance-advanced.js'),
+    'transfer-store': () => import('./transfer-store.js'),
+    cleanup: () => import('./cleanup.js'),
 };
 // Cache for loaded commands
-var loadedCommands = new Map();
+const loadedCommands = new Map();
 /**
  * Load a command lazily
  */
-function loadCommand(name) {
-    return __awaiter(this, void 0, Promise, function () {
-        var loader, module, command, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (loadedCommands.has(name)) {
-                        return [2 /*return*/, loadedCommands.get(name)];
-                    }
-                    loader = commandLoaders[name];
-                    if (!loader)
-                        return [2 /*return*/, undefined];
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, loader()];
-                case 2:
-                    module = _a.sent();
-                    command = (module["default"] || module[name + "Command"] || Object.values(module).find(function (v) { return typeof v === 'object' && v !== null && 'name' in v && 'description' in v; }));
-                    if (command) {
-                        loadedCommands.set(name, command);
-                        return [2 /*return*/, command];
-                    }
-                    return [3 /*break*/, 4];
-                case 3:
-                    error_1 = _a.sent();
-                    // Silently fail for missing optional commands
-                    if (process.env.DEBUG) {
-                        console.error("Failed to load command " + name + ":", error_1);
-                    }
-                    return [3 /*break*/, 4];
-                case 4: return [2 /*return*/, undefined];
-            }
-        });
-    });
+async function loadCommand(name) {
+    if (loadedCommands.has(name)) {
+        return loadedCommands.get(name);
+    }
+    const loader = commandLoaders[name];
+    if (!loader)
+        return undefined;
+    try {
+        const module = await loader();
+        // Try to find the command export (either default or named)
+        const command = (module.default || module[`${name}Command`] || Object.values(module).find((v) => typeof v === 'object' && v !== null && 'name' in v && 'description' in v));
+        if (command) {
+            loadedCommands.set(name, command);
+            return command;
+        }
+    }
+    catch (error) {
+        // Silently fail for missing optional commands
+        if (process.env.DEBUG) {
+            console.error(`Failed to load command ${name}:`, error);
+        }
+    }
+    return undefined;
 }
 // =============================================================================
 // Synchronous Imports for Core Commands (needed immediately at startup)
@@ -238,131 +181,35 @@ export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
 export { cleanupCommand } from './cleanup.js';
 // Lazy-loaded command re-exports (for backwards compatibility, but async-only)
-export function getConfigCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('config')];
-    }); });
-}
-export function getMigrateCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('migrate')];
-    }); });
-}
-export function getWorkflowCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('workflow')];
-    }); });
-}
-export function getHiveMindCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('hive-mind')];
-    }); });
-}
-export function getProcessCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('process')];
-    }); });
-}
-export function getTaskCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('task')];
-    }); });
-}
-export function getSessionCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('session')];
-    }); });
-}
-export function getNeuralCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('neural')];
-    }); });
-}
-export function getSecurityCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('security')];
-    }); });
-}
-export function getPerformanceCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('performance')];
-    }); });
-}
-export function getProvidersCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('providers')];
-    }); });
-}
-export function getPluginsCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('plugins')];
-    }); });
-}
-export function getDeploymentCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('deployment')];
-    }); });
-}
-export function getClaimsCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('claims')];
-    }); });
-}
-export function getEmbeddingsCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('embeddings')];
-    }); });
-}
-export function getCompletionsCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('completions')];
-    }); });
-}
-export function getAnalyzeCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('analyze')];
-    }); });
-}
-export function getRouteCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('route')];
-    }); });
-}
-export function getProgressCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('progress')];
-    }); });
-}
-export function getIssuesCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('issues')];
-    }); });
-}
-export function getRuvectorCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('ruvector')];
-    }); });
-}
-export function getGuidanceCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('guidance')];
-    }); });
-}
-export function getApplianceCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('appliance')];
-    }); });
-}
-export function getCleanupCommand() {
-    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, loadCommand('cleanup')];
-    }); });
-}
+export async function getConfigCommand() { return loadCommand('config'); }
+export async function getMigrateCommand() { return loadCommand('migrate'); }
+export async function getWorkflowCommand() { return loadCommand('workflow'); }
+export async function getHiveMindCommand() { return loadCommand('hive-mind'); }
+export async function getProcessCommand() { return loadCommand('process'); }
+export async function getTaskCommand() { return loadCommand('task'); }
+export async function getSessionCommand() { return loadCommand('session'); }
+export async function getNeuralCommand() { return loadCommand('neural'); }
+export async function getSecurityCommand() { return loadCommand('security'); }
+export async function getPerformanceCommand() { return loadCommand('performance'); }
+export async function getProvidersCommand() { return loadCommand('providers'); }
+export async function getPluginsCommand() { return loadCommand('plugins'); }
+export async function getDeploymentCommand() { return loadCommand('deployment'); }
+export async function getClaimsCommand() { return loadCommand('claims'); }
+export async function getEmbeddingsCommand() { return loadCommand('embeddings'); }
+export async function getCompletionsCommand() { return loadCommand('completions'); }
+export async function getAnalyzeCommand() { return loadCommand('analyze'); }
+export async function getRouteCommand() { return loadCommand('route'); }
+export async function getProgressCommand() { return loadCommand('progress'); }
+export async function getIssuesCommand() { return loadCommand('issues'); }
+export async function getRuvectorCommand() { return loadCommand('ruvector'); }
+export async function getGuidanceCommand() { return loadCommand('guidance'); }
+export async function getApplianceCommand() { return loadCommand('appliance'); }
+export async function getCleanupCommand() { return loadCommand('cleanup'); }
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup
  */
-export var commands = [
+export const commands = [
     // Core commands (synchronously loaded)
     initCommand,
     startCommand,
@@ -388,7 +235,7 @@ export var commands = [
 /**
  * Commands organized by category for help display
  */
-export var commandsByCategory = {
+export const commandsByCategory = {
     primary: [
         initCommand,
         startCommand,
@@ -433,20 +280,18 @@ export var commandsByCategory = {
         processCommand,
         applianceCommand,
         cleanupCommand,
-    ]
+    ],
 };
 /**
  * Command registry map for quick lookup
  * Supports both sync (core commands) and async (lazy-loaded) commands
  */
-export var commandRegistry = new Map();
+export const commandRegistry = new Map();
 // Register core commands and their aliases
-for (var _i = 0, commands_1 = commands; _i < commands_1.length; _i++) {
-    var cmd = commands_1[_i];
+for (const cmd of commands) {
     commandRegistry.set(cmd.name, cmd);
     if (cmd.aliases) {
-        for (var _a = 0, _b = cmd.aliases; _a < _b.length; _a++) {
-            var alias = _b[_a];
+        for (const alias of cmd.aliases) {
             commandRegistry.set(alias, cmd);
         }
     }
@@ -461,20 +306,17 @@ export function getCommand(name) {
 /**
  * Get command by name (async - supports lazy loading)
  */
-export function getCommandAsync(name) {
-    return __awaiter(this, void 0, Promise, function () {
-        var cached, synced;
-        return __generator(this, function (_a) {
-            cached = loadedCommands.get(name);
-            if (cached)
-                return [2 /*return*/, cached];
-            synced = commandRegistry.get(name);
-            if (synced)
-                return [2 /*return*/, synced];
-            // Try lazy loading
-            return [2 /*return*/, loadCommand(name)];
-        });
-    });
+export async function getCommandAsync(name) {
+    // Check already-loaded commands first
+    const cached = loadedCommands.get(name);
+    if (cached)
+        return cached;
+    // Check sync registry
+    const synced = commandRegistry.get(name);
+    if (synced)
+        return synced;
+    // Try lazy loading
+    return loadCommand(name);
 }
 /**
  * Check if command exists (sync check for core commands)
@@ -486,74 +328,50 @@ export function hasCommand(name) {
  * Get all command names (including aliases and lazy-loadable)
  */
 export function getCommandNames() {
-    var names = new Set(__spreadArray(__spreadArray(__spreadArray([], Array.from(commandRegistry.keys()), true), Array.from(loadedCommands.keys()), true), Object.keys(commandLoaders), true));
+    const names = new Set([
+        ...Array.from(commandRegistry.keys()),
+        ...Array.from(loadedCommands.keys()),
+        ...Object.keys(commandLoaders),
+    ]);
     return Array.from(names);
 }
 /**
  * Get all unique commands (excluding aliases)
  */
 export function getUniqueCommands() {
-    return commands.filter(function (cmd) { return !cmd.hidden; });
+    return commands.filter(cmd => !cmd.hidden);
 }
 /**
  * Load all commands (populates lazy-loaded commands)
  * Use this when you need all commands available synchronously
  */
-export function loadAllCommands() {
-    return __awaiter(this, void 0, Promise, function () {
-        var allCommands, _i, _a, name, cmd;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    allCommands = __spreadArray([], commands, true);
-                    _i = 0, _a = Object.keys(commandLoaders);
-                    _b.label = 1;
-                case 1:
-                    if (!(_i < _a.length)) return [3 /*break*/, 4];
-                    name = _a[_i];
-                    if (!!loadedCommands.has(name)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, loadCommand(name)];
-                case 2:
-                    cmd = _b.sent();
-                    if (cmd && !allCommands.includes(cmd)) {
-                        allCommands.push(cmd);
-                    }
-                    _b.label = 3;
-                case 3:
-                    _i++;
-                    return [3 /*break*/, 1];
-                case 4: return [2 /*return*/, allCommands];
+export async function loadAllCommands() {
+    const allCommands = [...commands];
+    for (const name of Object.keys(commandLoaders)) {
+        if (!loadedCommands.has(name)) {
+            const cmd = await loadCommand(name);
+            if (cmd && !allCommands.includes(cmd)) {
+                allCommands.push(cmd);
             }
-        });
-    });
+        }
+    }
+    return allCommands;
 }
 /**
  * Setup commands in a CLI instance
  */
 export function setupCommands(cli) {
-    for (var _i = 0, commands_2 = commands; _i < commands_2.length; _i++) {
-        var cmd = commands_2[_i];
+    for (const cmd of commands) {
         cli.command(cmd);
     }
 }
 /**
  * Setup all commands including lazy-loaded (async)
  */
-export function setupAllCommands(cli) {
-    return __awaiter(this, void 0, Promise, function () {
-        var allCommands, _i, allCommands_1, cmd;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, loadAllCommands()];
-                case 1:
-                    allCommands = _a.sent();
-                    for (_i = 0, allCommands_1 = allCommands; _i < allCommands_1.length; _i++) {
-                        cmd = allCommands_1[_i];
-                        cli.command(cmd);
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
+export async function setupAllCommands(cli) {
+    const allCommands = await loadAllCommands();
+    for (const cmd of allCommands) {
+        cli.command(cmd);
+    }
 }
 //# sourceMappingURL=index.js.map