@h-rig/cli-surface-plugin 0.0.6-alpha.156 → 0.0.6-alpha.158

package/dist/src/control-plane/workspace-ops.js

@@ -0,0 +1,639 @@
+// @bun
+// packages/cli-surface-plugin/src/control-plane/workspace-ops.ts
+import { spawn } from "child_process";
+import {
+  appendFileSync,
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { join, resolve } from "path";
+import { TASK_DATA_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { requireInstalledCapability } from "@rig/core/capability-loaders";
+var TaskDataCap = defineCapability(TASK_DATA_SERVICE_CAPABILITY);
+var taskData = () => requireInstalledCapability(TaskDataCap, "task-data capability unavailable: load @rig/task-sources-plugin (default bundle) before reading workspace task counts.");
+var ONLINE_REMOTE_HOST_STATUSES = new Set(["ready", "busy", "degraded", "draining"]);
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.flatMap((entry) => typeof entry === "string" && entry.trim().length > 0 ? [entry.trim()] : []) : [];
+}
+function asStringMap(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return {};
+  }
+  const entries = Object.entries(record).flatMap(([key, entry]) => {
+    if (typeof entry === "string" && entry.trim().length > 0) {
+      return [[key, entry]];
+    }
+    if (typeof entry === "number" || typeof entry === "boolean") {
+      return [[key, String(entry)]];
+    }
+    return [];
+  });
+  return Object.fromEntries(entries);
+}
+function parseScalar(raw) {
+  const value = raw.trim();
+  if (value.length === 0)
+    return "";
+  if (value === "null")
+    return null;
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (/^-?\d+$/.test(value))
+    return Number.parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value))
+    return Number.parseFloat(value);
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseYamlSubset(source) {
+  const lines = source.split(/\r?\n/).map((line) => line.replace(/\t/g, "  ")).filter((line) => line.trim().length > 0 && !line.trimStart().startsWith("#"));
+  const root = {};
+  const stack = [
+    { indent: -1, value: root }
+  ];
+  const ensureContainer = (indent) => {
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    return stack[stack.length - 1];
+  };
+  for (let index = 0;index < lines.length; index += 1) {
+    const rawLine = lines[index];
+    const indent = rawLine.match(/^ */)?.[0].length ?? 0;
+    const line = rawLine.trim();
+    const parent = ensureContainer(indent);
+    if (line.startsWith("- ")) {
+      const itemContent = line.slice(2);
+      if (!Array.isArray(parent.value)) {
+        continue;
+      }
+      if (itemContent.includes(":")) {
+        const [firstKey, ...rest] = itemContent.split(":");
+        const valueText2 = rest.join(":").trim();
+        const entry = {};
+        entry[firstKey.trim()] = valueText2.length > 0 ? parseScalar(valueText2) : "";
+        parent.value.push(entry);
+        stack.push({ indent, value: entry });
+      } else {
+        parent.value.push(parseScalar(itemContent));
+      }
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1 || !asRecord(parent.value)) {
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    const valueText = line.slice(colonIndex + 1).trim();
+    const parentRecord = parent.value;
+    if (valueText.length > 0) {
+      parentRecord[key] = parseScalar(valueText);
+      continue;
+    }
+    const nextLine = lines[index + 1]?.trim() ?? "";
+    const container = nextLine.startsWith("- ") ? [] : {};
+    parentRecord[key] = container;
+    stack.push({ indent, value: container });
+  }
+  return root;
+}
+function relativePath(rootPath, targetPath) {
+  return targetPath.startsWith(rootPath) ? targetPath.slice(rootPath.length + 1) || "." : targetPath;
+}
+function resolveRuntimeWorkspaceRoot(projectRoot) {
+  return resolve(process.env.RIG_TASK_WORKSPACE?.trim() || projectRoot);
+}
+function resolveServiceFabricPaths(projectRoot) {
+  const workspaceRoot = resolveRuntimeWorkspaceRoot(projectRoot);
+  const fabricRoot = resolve(workspaceRoot, ".rig", "service-fabric");
+  return {
+    workspaceRoot,
+    fabricRoot,
+    statePath: resolve(fabricRoot, "fabric-state.json"),
+    logsDir: resolve(fabricRoot, "logs")
+  };
+}
+function issueStatus(status) {
+  switch (status) {
+    case "ready":
+    case "open":
+    case "queued":
+    case "blocked":
+    case "completed":
+    case "draft":
+    case "cancelled":
+      return status;
+    case "in_progress":
+    case "under_review":
+      return "running";
+    case "unknown":
+      return "unknown";
+  }
+}
+function collectTaskCounts(projectRoot) {
+  const initial = {
+    total: 0,
+    ready: 0,
+    open: 0,
+    queued: 0,
+    running: 0,
+    blocked: 0,
+    failed: 0,
+    unknown: 0,
+    completed: 0,
+    draft: 0,
+    cancelled: 0
+  };
+  const snapshot = taskData().readSyncedTrackerState(projectRoot, {}, { allowLocalFallback: true });
+  for (const issue of snapshot.issues) {
+    if (!issue.id.startsWith("bd-"))
+      continue;
+    if (issue.issueType === "epic")
+      continue;
+    initial.total += 1;
+    initial[issueStatus(issue.status)] += 1;
+  }
+  return initial;
+}
+function listManifestDirs(rootPath) {
+  const candidates = [join(rootPath, "microservices")];
+  const discovered = new Set;
+  for (const candidate of candidates) {
+    if (!existsSync(candidate))
+      continue;
+    for (const entry of readdirSync(candidate, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith("_"))
+        continue;
+      const serviceDir = join(candidate, entry.name);
+      if (existsSync(join(serviceDir, "service.yaml"))) {
+        discovered.add(serviceDir);
+      }
+    }
+  }
+  return [...discovered].sort((left, right) => left.localeCompare(right));
+}
+function parsePortValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Number(value);
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return 0;
+}
+function resolveMonorepoWorkspaceRoot(projectRoot) {
+  return resolve(process.env.MONOREPO_ROOT?.trim() || projectRoot);
+}
+function resolveLocalWorkingDir(monorepoRoot, serviceDir, rawWorkingDir) {
+  if (!rawWorkingDir) {
+    return serviceDir;
+  }
+  if (rawWorkingDir.startsWith("/")) {
+    return rawWorkingDir;
+  }
+  if (rawWorkingDir.startsWith(".")) {
+    return resolve(serviceDir, rawWorkingDir);
+  }
+  return resolve(monorepoRoot, rawWorkingDir);
+}
+function readNativeServicePlans(projectRoot, selectedServices = []) {
+  const manifestDirs = listManifestDirs(projectRoot);
+  const warnings = [];
+  const services = [];
+  const monorepoRoot = resolveMonorepoWorkspaceRoot(projectRoot);
+  for (const serviceDir of manifestDirs) {
+    const manifestPath = join(serviceDir, "service.yaml");
+    try {
+      const parsed = asRecord(parseYamlSubset(readFileSync(manifestPath, "utf-8")));
+      const name = asString(parsed?.name) ?? serviceDir.split("/").at(-1) ?? "service";
+      if (selectedServices.length > 0 && !selectedServices.includes(name)) {
+        continue;
+      }
+      const localDev = asRecord(parsed?.local_dev);
+      const runtime = asString(parsed?.runtime) ?? "unknown";
+      const healthcheck = asString(parsed?.healthcheck) ?? "/health";
+      const routePrefix = asString(localDev?.route_prefix);
+      const command = asString(localDev?.command);
+      const requestedMode = asString(localDev?.mode);
+      const environment = asStringMap(localDev?.env);
+      const port = parsePortValue(environment.PORT) || parsePortValue(environment.HTTP_PORT) || parsePortValue(parsed?.port) || 0;
+      const workingDir = resolveLocalWorkingDir(monorepoRoot, serviceDir, asString(localDev?.working_dir));
+      const readinessPath = asString(localDev?.readiness_path) ?? healthcheck;
+      let mode = requestedMode === "process" || requestedMode !== "stub" && command ? "process" : "stub";
+      if (requestedMode === "proxy" && !command) {
+        warnings.push(`${relativePath(projectRoot, manifestPath)} declares local_dev.mode=proxy without a command; treating it as a stub`);
+        mode = "stub";
+      }
+      if (mode === "process" && !command) {
+        warnings.push(`${relativePath(projectRoot, manifestPath)} declares process local_dev mode without a command; treating it as a stub`);
+        mode = "stub";
+      }
+      services.push({
+        name,
+        relativeRootPath: relativePath(projectRoot, serviceDir),
+        absoluteRootPath: serviceDir,
+        runtime,
+        port,
+        healthcheck,
+        routePrefix,
+        mode,
+        command: mode === "process" ? command : null,
+        workingDir,
+        environment,
+        readinessPath
+      });
+    } catch (error) {
+      warnings.push(`Failed to parse ${relativePath(projectRoot, manifestPath)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { services, warnings };
+}
+function readPersistedFabricState(projectRoot) {
+  const { statePath } = resolveServiceFabricPaths(projectRoot);
+  if (!existsSync(statePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(statePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writePersistedFabricState(projectRoot, state) {
+  const { fabricRoot, logsDir, statePath } = resolveServiceFabricPaths(projectRoot);
+  mkdirSync(fabricRoot, { recursive: true });
+  mkdirSync(logsDir, { recursive: true });
+  writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+}
+function isProcessRunning(pid) {
+  if (!pid || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stopProcess(pid) {
+  if (!pid || pid <= 0) {
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(pid)) {
+      return;
+    }
+    await Bun.sleep(100);
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {}
+}
+async function probeReadiness(service, timeoutMs = 1000) {
+  if (service.mode === "stub") {
+    return true;
+  }
+  if (!isProcessRunning(service.pid) || service.port <= 0) {
+    return false;
+  }
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`http://127.0.0.1:${service.port}${service.readinessPath}`, {
+      signal: controller.signal
+    });
+    return response.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function waitForServiceHealthy(service, timeoutMs = 30000) {
+  if (service.mode === "stub") {
+    return true;
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await probeReadiness(service, 1000)) {
+      return true;
+    }
+    if (!isProcessRunning(service.pid)) {
+      return false;
+    }
+    await Bun.sleep(250);
+  }
+  return false;
+}
+function materializeStateFromPlans(projectRoot, plans, persisted) {
+  const persistedByName = new Map((persisted?.services ?? []).map((service) => [service.name, service]));
+  const { logsDir } = resolveServiceFabricPaths(projectRoot);
+  return plans.map((plan) => {
+    const previous = persistedByName.get(plan.name);
+    return {
+      ...plan,
+      pid: previous?.pid ?? null,
+      logPath: previous?.logPath ?? resolve(logsDir, `${plan.name}.log`),
+      status: previous?.status ?? "stopped"
+    };
+  });
+}
+function summarizeFabricState(projectRoot, services, warnings, updatedAt) {
+  const { fabricRoot } = resolveServiceFabricPaths(projectRoot);
+  const healthyServiceCount = services.filter((service) => service.status === "healthy").length;
+  const status = services.length === 0 ? "empty" : services.every((service) => service.status === "stopped") ? "stopped" : services.every((service) => service.status === "healthy") ? "ready" : services.some((service) => service.status === "booting") ? "booting" : "degraded";
+  return {
+    updatedAt,
+    status,
+    serviceCount: services.length,
+    healthyServiceCount,
+    stateDir: fabricRoot,
+    services: services.map((service) => ({
+      name: service.name,
+      relativeRootPath: service.relativeRootPath,
+      absoluteRootPath: service.absoluteRootPath,
+      mode: service.mode,
+      port: service.port,
+      healthcheck: service.healthcheck,
+      routePrefix: service.routePrefix,
+      command: service.command,
+      environment: service.environment,
+      status: service.status,
+      pid: service.pid,
+      logPath: service.logPath
+    })),
+    warnings
+  };
+}
+function readWorkspaceTopology(projectRoot, compiledAt = new Date().toISOString()) {
+  const manifestDirs = listManifestDirs(projectRoot);
+  const warnings = [];
+  const services = [];
+  for (const serviceDir of manifestDirs) {
+    const manifestPath = join(serviceDir, "service.yaml");
+    try {
+      const parsed = asRecord(parseYamlSubset(readFileSync(manifestPath, "utf-8")));
+      const name = asString(parsed?.name) ?? serviceDir.split("/").at(-1) ?? "service";
+      const runtime = asString(parsed?.runtime) ?? "unknown";
+      const portValue = typeof parsed?.port === "number" ? parsed.port : typeof parsed?.port === "string" ? Number(parsed.port) : NaN;
+      services.push({
+        name,
+        relativeRootPath: relativePath(projectRoot, serviceDir),
+        runtime,
+        port: Number.isFinite(portValue) ? Number(portValue) : null,
+        healthcheck: asString(parsed?.healthcheck),
+        splitReadyChecklist: asStringArray(parsed?.split_ready_checklist)
+      });
+    } catch (error) {
+      warnings.push(`Failed to parse ${relativePath(projectRoot, manifestPath)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return {
+    compiledAt,
+    status: services.length === 0 ? "empty" : warnings.length > 0 ? "degraded" : "ready",
+    manifestCount: manifestDirs.length,
+    serviceCount: services.length,
+    services,
+    warnings
+  };
+}
+function discoverRemoteHostManifests(projectRoot) {
+  const workspaceRoot = resolveRuntimeWorkspaceRoot(projectRoot);
+  return [
+    join(projectRoot, "rig.remote-hosts.yaml"),
+    resolve(workspaceRoot, ".rig", "remote-hosts.yaml")
+  ].filter((candidate) => existsSync(candidate));
+}
+function readWorkspaceRemoteFleet(projectRoot, updatedAt = new Date().toISOString()) {
+  const manifestPaths = discoverRemoteHostManifests(projectRoot);
+  const warnings = [];
+  const hostsById = new Map;
+  for (const manifestPath of manifestPaths) {
+    try {
+      const parsed = asRecord(parseYamlSubset(readFileSync(manifestPath, "utf-8")));
+      const hosts2 = Array.isArray(parsed?.hosts) ? parsed.hosts : [];
+      for (const entry of hosts2) {
+        const host = asRecord(entry);
+        const id = asString(host?.id);
+        const name = asString(host?.name);
+        const baseUrl = asString(host?.base_url);
+        if (!id || !name || !baseUrl) {
+          warnings.push(`Skipped invalid remote host entry in ${relativePath(projectRoot, manifestPath)}`);
+          continue;
+        }
+        hostsById.set(id, {
+          id,
+          name,
+          baseUrl,
+          workspacePath: asString(host?.workspace_path),
+          transport: asString(host?.transport) ?? "websocket",
+          hostname: asString(host?.hostname),
+          region: asString(host?.region),
+          labels: asStringArray(host?.labels),
+          capabilities: asStringArray(host?.capabilities),
+          runtimeAdapters: ["pi"],
+          status: asString(host?.status) ?? "offline",
+          currentLeaseCount: typeof host?.current_lease_count === "number" ? Number(host.current_lease_count) : 0,
+          manifestPath: relativePath(projectRoot, manifestPath)
+        });
+      }
+    } catch (error) {
+      warnings.push(`Failed to parse ${relativePath(projectRoot, manifestPath)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const hosts = [...hostsById.values()].sort((left, right) => left.name.localeCompare(right.name));
+  const onlineHostCount = hosts.filter((host) => ONLINE_REMOTE_HOST_STATUSES.has(host.status)).length;
+  return {
+    updatedAt,
+    status: hosts.length === 0 ? "empty" : warnings.length > 0 || hosts.some((host) => host.status === "degraded" || host.status === "quarantined") ? "degraded" : onlineHostCount > 0 ? "ready" : "degraded",
+    manifestCount: manifestPaths.length,
+    hostCount: hosts.length,
+    onlineHostCount,
+    hosts,
+    warnings
+  };
+}
+async function readWorkspaceServiceFabric(projectRoot) {
+  try {
+    const updatedAt = new Date().toISOString();
+    const persisted = readPersistedFabricState(projectRoot);
+    const plans = readNativeServicePlans(projectRoot);
+    const services = materializeStateFromPlans(projectRoot, plans.services, persisted);
+    for (const service of services) {
+      if (service.status === "stopped") {
+        continue;
+      }
+      if (!isProcessRunning(service.pid)) {
+        service.pid = null;
+        service.status = "stopped";
+        continue;
+      }
+      service.status = await probeReadiness(service, 1000) ? "healthy" : "degraded";
+    }
+    const state = {
+      updatedAt,
+      rootPath: projectRoot,
+      services
+    };
+    writePersistedFabricState(projectRoot, state);
+    return summarizeFabricState(projectRoot, services, plans.warnings, updatedAt);
+  } catch (error) {
+    return {
+      status: "unavailable",
+      warnings: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+async function mutateWorkspaceServiceFabric(projectRoot, command, services = []) {
+  const updatedAt = new Date().toISOString();
+  const persisted = readPersistedFabricState(projectRoot);
+  const plans = readNativeServicePlans(projectRoot, services);
+  const stateServices = materializeStateFromPlans(projectRoot, plans.services, persisted);
+  if (command === "verify") {
+    for (const service of stateServices) {
+      if (service.status === "stopped") {
+        continue;
+      }
+      if (!isProcessRunning(service.pid)) {
+        service.pid = null;
+        service.status = "stopped";
+        continue;
+      }
+      service.status = await probeReadiness(service, 1000) ? "healthy" : "degraded";
+    }
+  } else if (command === "up") {
+    const { logsDir } = resolveServiceFabricPaths(projectRoot);
+    mkdirSync(logsDir, { recursive: true });
+    for (const service of stateServices) {
+      if (service.mode === "stub") {
+        service.pid = null;
+        service.status = "healthy";
+        continue;
+      }
+      if (isProcessRunning(service.pid) && await probeReadiness(service, 1000)) {
+        service.status = "healthy";
+        continue;
+      }
+      if (isProcessRunning(service.pid)) {
+        await stopProcess(service.pid);
+      }
+      const logPath = resolve(logsDir, `${service.name}.log`);
+      service.logPath = logPath;
+      appendFileSync(logPath, `
+=== ${updatedAt} :: rig service-fabric up :: ${service.name} ===
+`, "utf-8");
+      const logFd = openSync(logPath, "a");
+      try {
+        const child = spawn(service.command || "true", {
+          cwd: service.workingDir,
+          env: { ...process.env, ...service.environment },
+          shell: true,
+          detached: true,
+          stdio: ["ignore", logFd, logFd]
+        });
+        child.unref();
+        service.pid = child.pid ?? null;
+        service.status = "booting";
+      } finally {
+        closeSync(logFd);
+      }
+      service.status = await waitForServiceHealthy(service) ? "healthy" : "degraded";
+      if (service.status !== "healthy" && !isProcessRunning(service.pid)) {
+        service.pid = null;
+        service.status = "failed";
+      }
+    }
+  } else if (command === "down") {
+    for (const service of stateServices) {
+      await stopProcess(service.pid);
+      service.pid = null;
+      service.status = "stopped";
+    }
+  }
+  const merged = new Map;
+  for (const service of persisted?.services ?? []) {
+    merged.set(service.name, service);
+  }
+  for (const service of stateServices) {
+    merged.set(service.name, service);
+  }
+  const nextState = {
+    updatedAt,
+    rootPath: projectRoot,
+    services: [...merged.values()].sort((left, right) => left.name.localeCompare(right.name))
+  };
+  writePersistedFabricState(projectRoot, nextState);
+  return summarizeFabricState(projectRoot, stateServices, plans.warnings, updatedAt);
+}
+function countRuntimeDirs(projectRoot) {
+  const runtimeRoot = resolve(resolveRuntimeWorkspaceRoot(projectRoot), ".rig", "runtime", "agents");
+  if (!existsSync(runtimeRoot)) {
+    return 0;
+  }
+  return readdirSync(runtimeRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).length;
+}
+function countArtifactTaskDirs(projectRoot) {
+  const artifactRoot = resolve(resolveRuntimeWorkspaceRoot(projectRoot), "artifacts");
+  if (!existsSync(artifactRoot)) {
+    return 0;
+  }
+  return readdirSync(artifactRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "remote-runs").length;
+}
+async function readWorkspaceSummary(projectRoot) {
+  const generatedAt = new Date().toISOString();
+  const warnings = [];
+  const topology = readWorkspaceTopology(projectRoot, generatedAt);
+  const remoteFleet = readWorkspaceRemoteFleet(projectRoot, generatedAt);
+  const serviceFabric = await readWorkspaceServiceFabric(projectRoot);
+  if (serviceFabric?.warnings) {
+    warnings.push(...serviceFabric.warnings.map((warning) => String(warning)));
+  }
+  warnings.push(...topology.warnings, ...remoteFleet.warnings);
+  return {
+    rootPath: projectRoot,
+    taskCounts: collectTaskCounts(projectRoot),
+    runtimeCount: countRuntimeDirs(projectRoot),
+    artifactTaskCount: countArtifactTaskDirs(projectRoot),
+    failedApproachesPresent: existsSync(resolve(resolveRuntimeWorkspaceRoot(projectRoot), ".rig", "state", "failed_approaches.md")),
+    topology,
+    remoteFleet,
+    serviceFabric,
+    warnings,
+    generatedAt
+  };
+}
+export {
+  readWorkspaceTopology,
+  readWorkspaceSummary,
+  readWorkspaceServiceFabric,
+  readWorkspaceRemoteFleet,
+  mutateWorkspaceServiceFabric
+};

package/dist/src/help-catalog-data.d.ts

@@ -0,0 +1,7 @@
+import type { HelpCatalog, HelpCommand, HelpGroup, TopLevelSection } from "@rig/contracts";
+export declare function helpCatalog(): HelpCatalog;
+export declare const TOP_LEVEL_SECTIONS: TopLevelSection[];
+export declare const PRIMARY_GROUPS: HelpGroup[];
+export declare const ADVANCED_GROUPS: HelpGroup[];
+export declare const ADVANCED_COMMANDS: HelpCommand[];
+export declare const ALL_GROUPS: HelpGroup[];