@aria-cli/cli 1.0.14

package/bin/aria-dev.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+/**
+ * ARIA CLI — Development entry point (runs from source, no build needed)
+ * Registers tsx loader then delegates to the production entry point.
+ */
+
+import { register } from "node:module";
+import { pathToFileURL } from "node:url";
+
+try {
+  register("tsx/esm", pathToFileURL("./"));
+} catch {}
+
+await import("./aria.js");

package/bin/aria.js

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+
+/**
+ * ARIA CLI - Command-line interface for ARIA
+ *
+ * Usage:
+ *   aria                    - Start interactive REPL (Ink UI)
+ *   aria "message"          - Start REPL and auto-send first message
+ *   aria -r <id>            - Resume session by ID/prefix in REPL
+ *   aria -c                 - Continue most recent session in REPL
+ *   aria daemon             - Autonomous wake loop
+ *   aria --help             - Show help
+ *
+ * Heap enforcement:
+ *   If --max-old-space-size is not set, the script re-execs once
+ *   with the flag. The re-exec parent does zero application work.
+ */
+
+// ── Crash diagnostic infrastructure ─────────────────────────────────
+// Registered before ANY other code so uncaught errors are always captured.
+import { writeFileSync, appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+import { RESTART_KIND_ENV, RESUME_SESSION_ENV } from "@aria-cli/types";
+import { withReplCleanup } from "../dist/repl-cleanup.js";
+import { installOwnerLease } from "./install-owner-lease.js";
+
+function writeCrashReport(type, error) {
+  try {
+    const crashDir = join(homedir(), ".aria", "crash-reports");
+    mkdirSync(crashDir, { recursive: true });
+    const sessionId = process.env[RESUME_SESSION_ENV] || "unknown";
+    const mem = process.memoryUsage();
+    const report = {
+      timestamp: new Date().toISOString(),
+      sessionId,
+      type,
+      error: {
+        message: error?.message ?? String(error),
+        stack: error?.stack ?? undefined,
+        name: error?.name ?? undefined,
+      },
+      process: {
+        pid: process.pid,
+        heapUsedMb: Math.round((mem.heapUsed / 1024 / 1024) * 100) / 100,
+        rssMb: Math.round((mem.rss / 1024 / 1024) * 100) / 100,
+        uptime: Math.round(process.uptime()),
+      },
+    };
+    writeFileSync(join(crashDir, "latest.json"), JSON.stringify(report, null, 2));
+
+    // Also append to the central error events journal (CEH integration)
+    const ariaDir = join(homedir(), ".aria");
+    const errorEventsPath = join(ariaDir, "error-events.jsonl");
+    const firstFrame = error?.stack?.split("\n")[1]?.trim() ?? "";
+    const bucketedTime = Math.floor(Date.now() / 10000);
+    const errorId = createHash("sha256")
+      .update(`${error?.message ?? ""}|${firstFrame}|${bucketedTime}`)
+      .digest("hex")
+      .slice(0, 12);
+
+    const causeChain = [];
+    let cause = error?.cause;
+    const seen = new Set();
+    while (cause instanceof Error && !seen.has(cause)) {
+      seen.add(cause);
+      causeChain.push(`${cause.name}: ${cause.message}`);
+      cause = cause.cause;
+    }
+
+    const relatedFiles = [];
+    if (error?.stack) {
+      for (const line of error.stack.split("\n")) {
+        const match = line.match(/\((?:file:\/\/)?([^:)]+):\d+:\d+\)/);
+        if (match?.[1]?.includes("packages/") && !match[1].includes("node_modules")) {
+          relatedFiles.push(match[1]);
+        }
+      }
+    }
+
+    const errorEntry = {
+      id: `crash-${errorId}`,
+      timestamp: report.timestamp,
+      severity: 0,
+      category: "crash",
+      domain: "cli",
+      name: error?.name ?? "UnknownError",
+      message: error?.message ?? String(error),
+      code: error?.code ?? undefined,
+      stackTrace: error?.stack,
+      causeChain,
+      recoverable: false,
+      state: {
+        environment: { nodeVersion: process.version, platform: process.platform },
+        processInfo: report.process,
+      },
+      relatedFiles,
+      relatedErrors: [],
+      status: "new",
+    };
+    appendFileSync(errorEventsPath, JSON.stringify(errorEntry) + "\n", "utf-8");
+  } catch {
+    // Best effort — crash report writing must never itself throw
+  }
+}
+
+process.on("uncaughtException", (error, origin) => {
+  writeCrashReport("uncaughtException", error);
+  process.stderr.write(`[aria] FATAL uncaughtException (origin: ${origin}):\n`);
+  process.stderr.write(`${error?.stack ?? error}\n`);
+  process.exit(1);
+});
+
+process.on("unhandledRejection", (reason) => {
+  writeCrashReport("unhandledRejection", reason);
+  process.stderr.write(`[aria] FATAL unhandledRejection:\n`);
+  process.stderr.write(`${reason?.stack ?? reason}\n`);
+  process.exit(1);
+});
+
+installOwnerLease();
+
+// Determine mode based on arguments
+const args = process.argv.slice(2);
+
+if (args[0] === "-v" || args[0] === "--version") {
+  // Global flags that shouldn't be treated as REPL messages
+  import("../dist/commands/index.js")
+    .then(({ program }) => program.parseAsync(process.argv))
+    .catch((error) => {
+      process.stderr.write(`Error: ${error.message}\n`);
+      process.exitCode = 1;
+    });
+} else {
+  // Existing routing: subcommand check + REPL
+  const subcommands = [
+    "daemon",
+    "auth",
+    "arions",
+    "headless",
+    "call",
+    "pairing",
+    "runtime-cutover-reset",
+    "--help",
+    "-h",
+  ];
+  const isSubcommand =
+    args.length > 0 && (subcommands.includes(args[0]) || args[0].startsWith("--"));
+
+  // Parse -r/--resume and -c/--continue flags for REPL session resume
+  let resumeArg = null;
+  let continueSession = false;
+  const remainingArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "-r" || args[i] === "--resume") && !isSubcommand) {
+      if (i + 1 >= args.length) {
+        process.stderr.write("Error: -r/--resume requires a session ID\n");
+        process.exit(2);
+      }
+      resumeArg = args[++i];
+    } else if ((args[i] === "-c" || args[i] === "--continue") && !isSubcommand) {
+      continueSession = true;
+    } else {
+      remainingArgs.push(args[i]);
+    }
+  }
+  if (resumeArg && continueSession) {
+    process.stderr.write("Error: -r/--resume and -c/--continue are mutually exclusive\n");
+    process.exit(2);
+  }
+
+  // Auto-resume from supervisor: session ID passed via env var.
+  // The child always resumes silently; only explicit CLI args become an
+  // auto-submitted initial message.
+  if (!resumeArg && !continueSession && process.env[RESUME_SESSION_ENV]) {
+    resumeArg = process.env[RESUME_SESSION_ENV];
+    // Clear the env vars so they don't propagate to further restarts
+    delete process.env[RESUME_SESSION_ENV];
+    delete process.env[RESTART_KIND_ENV];
+  }
+
+  // Treat non-flag remaining args as initial message: `aria "hello"` → REPL with first message
+  // Both crash resume and explicit /restart resume the session silently.
+  const initialMessage =
+    !isSubcommand && remainingArgs.length > 0 ? remainingArgs.join(" ") : undefined;
+
+  if (!isSubcommand) {
+    // Ensure adequate V8 heap for large Memoria databases (history.db > 1 GB).
+    // Re-exec once if the flag is missing. The re-exec parent does zero
+    // application work — just forwards stdio and exit code.
+    if (!process.execArgv.some((a) => a.includes("max-old-space-size"))) {
+      process.on("SIGINT", () => {
+        /* child owns the terminal */
+      });
+      import("node:child_process").then(({ spawn }) => {
+        const child = spawn(
+          process.execPath,
+          [
+            "--max-old-space-size=8192",
+            ...process.execArgv,
+            process.argv[1],
+            ...process.argv.slice(2),
+          ],
+          { stdio: "inherit" },
+        );
+        child.on("close", (code) => process.exit(code ?? 1));
+      });
+    } else {
+      // Run the Ink REPL directly — no supervisor loop.
+      // createCliContext runs in parallel with module imports to overlap
+      // the ~1.2s auth resolution with ~0.5s of import/init work.
+      Promise.resolve()
+        .then(async () => {
+          const { createCliContext } = await import("../dist/cli-context.js");
+          const { getAriaDir } = await import("../dist/config.js");
+          const { ensureDaemon } = await import("../dist/ensure-daemon.js");
+
+          const ariaDir = getAriaDir();
+
+          // Start auth resolution immediately — runs in parallel with imports below
+          const ctxPromise = createCliContext();
+
+          // Parallel: import heavy modules while auth resolves
+          const [
+            { attachExistingLocalControlClient },
+            { startInkRepl },
+            { ArionManager, ArionStorage },
+            { Memoria },
+            { ArionSession },
+            { SessionHistory },
+          ] = await Promise.all([
+            import("../dist/local-control-client.js"),
+            import("../dist/ink-repl.js"),
+            import("@aria-cli/aria"),
+            import("@aria-cli/memoria"),
+            import("../dist/session.js"),
+            import("../dist/history/index.js"),
+          ]);
+
+          // Await the context (auth likely finished during parallel imports)
+          const ctx = await ctxPromise;
+          await ensureDaemon(ctx);
+
+          const bootstrapAttachedLocalControl = await attachExistingLocalControlClient({
+            ariaHome: ariaDir,
+            clientKind: "tui",
+          });
+
+          const ariaMemoriaPath =
+            process.env.ARIA_MEMORY_PATH || `${ctx.ariaDir}/arions/ARIA/memory.db`;
+          const ariaMemoria = new Memoria({ path: ariaMemoriaPath, router: ctx.router });
+          ariaMemoria.initialize().catch((err) => {
+            console.debug(
+              `[aria] Memoria background init failed (will retry on use): ${err?.message ?? err}`,
+            );
+          });
+
+          const aria = {
+            components: { memoria: ariaMemoria },
+            async recallUserName() {
+              try {
+                const db = ariaMemoria.storage?.getDatabase?.();
+                if (!db) return null;
+                const row = db.prepare("SELECT value FROM config WHERE key = 'user_profile'").get();
+                if (!row?.value) return null;
+                const profile = JSON.parse(row.value);
+                return profile.name ?? null;
+              } catch {
+                return null;
+              }
+            },
+            async shutdown() {
+              await ariaMemoria.close();
+            },
+          };
+
+          const arionStorage = new ArionStorage(ctx.ariaDir);
+          const arionManager = new ArionManager(arionStorage, ctx.memoriaFactory);
+          await arionManager.initialize();
+          arionManager.setRouter(ctx.router);
+          if (!bootstrapAttachedLocalControl) {
+            throw new Error("[aria] Attached REPL requires an existing local-control runtime");
+          }
+
+          // Initialize session history for input persistence
+          const arionName = ctx.config.activeArion?.trim() || "ARIA";
+          const historyDbPath = SessionHistory.resolvePerArionPath(ctx.ariaDir, arionName);
+          SessionHistory.migrateJsonlLogs(ctx.ariaDir, arionName);
+          const sessionHistory = new SessionHistory(historyDbPath);
+          const inputHistory = sessionHistory.getInputHistory(100);
+          const saveInputHistory = (input) => sessionHistory.addInputHistory(input);
+
+          // Resolve -r / -c to a session ID
+          let resumeSessionId = undefined;
+          if (resumeArg) {
+            const resolved = sessionHistory.findSessionByPrefix(resumeArg);
+            if (!resolved) {
+              process.stderr.write(`Error: No session found matching "${resumeArg}"\n`);
+              process.exit(2);
+            }
+            resumeSessionId = resolved;
+          } else if (continueSession) {
+            const recent = sessionHistory.listSessions(1);
+            if (recent.length === 0) {
+              process.stderr.write("Error: No recent sessions to continue\n");
+              process.exit(2);
+            }
+            resumeSessionId = recent[0].id;
+          }
+
+          const session = new ArionSession({
+            manager: arionManager,
+            router: ctx.router,
+            memoria: aria.components.memoria,
+            onArionRest: async () => {},
+          });
+          await session.initialize(ctx.config.activeArion);
+
+          // Pre-cache username for instant display
+          let cachedUserName = null;
+          try {
+            const db = ariaMemoria.storage?.getDatabase?.();
+            if (db) {
+              const row = db.prepare("SELECT value FROM config WHERE key = 'user_profile'").get();
+              if (row?.value) {
+                cachedUserName = JSON.parse(row.value).name ?? null;
+              }
+            }
+          } catch {}
+
+          await startInkRepl(
+            session,
+            arionManager,
+            ctx.router,
+            aria,
+            bootstrapAttachedLocalControl,
+            ctx,
+            inputHistory,
+            saveInputHistory,
+            sessionHistory,
+            initialMessage,
+            cachedUserName,
+            resumeSessionId,
+            ctx.availableModels,
+            ctx.refreshAvailableModels,
+            ctx.credentialHints,
+            ctx.authResolver,
+          );
+        })
+        .catch((error) => {
+          writeCrashReport("ink-repl-rejected", error);
+          console.error("Error starting Ink REPL:", error.message);
+          process.exit(1);
+        });
+    }
+  } else {
+    // Subcommand provided - parse commands
+    import("../dist/commands/index.js").then(({ program }) => {
+      program.parseAsync(process.argv).catch((error) => {
+        console.error("Error:", error.message);
+        process.exit(1);
+      });
+    });
+  }
+}

package/bin/install-owner-lease.d.ts

@@ -0,0 +1,8 @@
+export interface InstallOwnerLeaseOptions {
+  env?: NodeJS.ProcessEnv;
+  processRef?: NodeJS.Process;
+  pollMs?: number;
+  onOwnerGone?: (ownerPid: number) => void;
+}
+
+export function installOwnerLease(options?: InstallOwnerLeaseOptions): () => void;

package/bin/install-owner-lease.js

@@ -0,0 +1,53 @@
+const DEFAULT_OWNER_LEASE_POLL_MS = 1_000;
+
+export function installOwnerLease({
+  env = process.env,
+  processRef = process,
+  pollMs = DEFAULT_OWNER_LEASE_POLL_MS,
+  onOwnerGone,
+} = {}) {
+  const ownerPidRaw = env.ARIA_HARNESS_OWNER_PID;
+  if (!ownerPidRaw) {
+    return () => {};
+  }
+
+  const ownerPid = Number.parseInt(ownerPidRaw, 10);
+  if (!Number.isFinite(ownerPid) || ownerPid <= 0) {
+    throw new Error(`ARIA_HARNESS_OWNER_PID must be a positive integer, got: ${ownerPidRaw}`);
+  }
+
+  let released = false;
+  const interval = setInterval(() => {
+    if (released) {
+      return;
+    }
+
+    try {
+      processRef.kill(ownerPid, 0);
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+      if (code && code !== "ESRCH") {
+        return;
+      }
+      released = true;
+      clearInterval(interval);
+      if (onOwnerGone) {
+        onOwnerGone(ownerPid);
+        return;
+      }
+      processRef.kill(processRef.pid, "SIGTERM");
+    }
+  }, pollMs);
+  interval.unref?.();
+
+  const dispose = () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    clearInterval(interval);
+  };
+
+  processRef.once("exit", dispose);
+  return dispose;
+}

package/dist/.aria-build-stamp.json

@@ -0,0 +1,4 @@
+{
+  "label": "@aria-cli/cli",
+  "fingerprint": "15ad3854a14acddf3792b278cbaafbab91852c9537040d32e8b8578b2124fe7d"
+}

package/dist/attached-local-control-client.d.ts

@@ -0,0 +1,90 @@
+import type { MemoriaFactory, RunSessionConfig, DaemonSafetyPolicy } from "@aria-cli/aria";
+import type { AuthResolver } from "@aria-cli/auth";
+import type { ModelRouter } from "@aria-cli/models";
+import { type ClientId, type NodeId, type RuntimeId } from "@aria-cli/tools";
+import type { HostClientKind } from "@aria-cli/server/runtime/host-supervisor";
+import type { AttachedLocalControlApi, LocalControlApi } from "@aria-cli/server/runtime/local-control-api";
+export interface AttachedLocalControlClient {
+    nodeId: NodeId;
+    runtimeId: RuntimeId;
+    port: number;
+    ownership: "started" | "reattached";
+    attachedClientId?: string;
+    attachedClientAuthToken?: string;
+    control: AttachedLocalControlApi;
+    release(options?: {
+        preserveRuntime?: boolean;
+    }): Promise<void>;
+}
+export declare function requestRuntimeSocketLease(runtimeSocket: string, payload: unknown): Promise<{
+    clientId: ClientId;
+    clientAuthToken: string;
+    release(): Promise<void>;
+}>;
+export declare function attachExistingLocalControlClient(options: {
+    ariaHome: string;
+    clientKind: HostClientKind;
+    pollIntervalMs?: number;
+}): Promise<AttachedLocalControlClient | null>;
+export declare function attachLocalControlClient(options: {
+    ariaHome: string;
+    arionName: string;
+    clientKind: HostClientKind;
+    runtimeLifecycle?: "scoped" | "persistent";
+    memoriaFactory?: MemoriaFactory;
+    router?: ModelRouter;
+    authResolver?: AuthResolver;
+    runSessionConfig?: RunSessionConfig;
+    mcpServers?: import("@aria-cli/tools").MCPServerConfig[];
+    daemonSafetyPolicy?: DaemonSafetyPolicy;
+    autonomousIntervalMs?: number;
+    signal?: AbortSignal;
+    silent?: boolean;
+    port?: number;
+    pollIntervalMs?: number;
+}): Promise<AttachedLocalControlClient>;
+export declare function resolveLocalControlClient(options: {
+    ariaHome: string;
+    pollIntervalMs?: number;
+}): Promise<LocalControlApi | null>;
+export declare function resolveLocalControlClientSync(options: {
+    ariaHome: string;
+    pollIntervalMs?: number;
+    [key: string]: unknown;
+}): LocalControlApi | null;
+export interface ResilientAttachedClientOptions {
+    /** Path to the daemon's Unix socket */
+    runtimeSocket: string;
+    /** Client kind for the lease request */
+    clientKind?: string;
+    /** Display name for this client (e.g. arion name) */
+    displayName?: string;
+    /** Path to write diagnostic logs (e.g. ~/.aria/logs) */
+    logDir?: string;
+}
+export interface ResilientAttachedClient {
+    /** The self-healing API proxy. Survives daemon restarts transparently. */
+    api: AttachedLocalControlApi;
+    /** Current client ID (changes on reattach) */
+    getClientId(): string | undefined;
+    /** Current auth token (changes on reattach) */
+    getClientAuthToken(): string | undefined;
+    /** Release the lease and stop reconnection */
+    release(): Promise<void>;
+}
+/**
+ * Creates a self-healing AttachedLocalControlApi that survives daemon restarts.
+ *
+ * This is the ONLY correct way to get a long-lived client to the daemon.
+ * It fuses lease acquisition, auth credential management, stale-lease
+ * reattach with exponential backoff, and diagnostic logging into a single
+ * object. Callers get an API that "just works" — they never touch leases,
+ * auth tokens, or retry logic.
+ *
+ * On any call failure (stale lease, ECONNRESET, EPIPE, etc.):
+ *   1. Acquires a fresh lease from the daemon
+ *   2. Rebuilds the inner client with new credentials
+ *   3. Retries the call (up to 4 attempts with exponential backoff)
+ *   4. Logs every step to logDir/reattach.jsonl
+ */
+export declare function createResilientAttachedClient(options: ResilientAttachedClientOptions): Promise<ResilientAttachedClient>;

package/dist/bootstrap-local-control-client.d.ts

@@ -0,0 +1 @@
+export { assertAttachableRuntimeBootstrap, createLocalControlClient, type RuntimeBootstrapSource, } from "./local-control-http-client.js";

package/dist/capability-aware-method-proxy.d.ts

@@ -0,0 +1 @@
+export declare function createCapabilityAwareMethodProxy<T extends object>(getTarget: () => T | null | undefined): T;

package/dist/cli-context.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared CLI bootstrap context used by all CLI entry points (REPL, daemon, headless).
+ *
+ * Eliminates the duplicated config → env vars → router → pool pattern that
+ * previously appeared in every CLI command.
+ */
+import { ModelDiscovery, type ModelRouter } from "@aria-cli/models";
+import type { CredentialHints, ReadonlyModelDefinition } from "@aria-cli/models";
+import { createRuntimeAuthContext } from "@aria-cli/auth";
+import { MemoriaPool } from "@aria-cli/aria";
+import { loadConfig } from "./config.js";
+import { loadAriaConfig } from "./config/index.js";
+export interface CliContext {
+    config: ReturnType<typeof loadConfig>;
+    router: ModelRouter;
+    pool: InstanceType<typeof MemoriaPool>;
+    memoriaFactory: ReturnType<InstanceType<typeof MemoriaPool>["toFactory"]>;
+    ariaDir: string;
+    projectConfig: Awaited<ReturnType<typeof loadAriaConfig>>;
+    discovery: InstanceType<typeof ModelDiscovery>;
+    availableModels: ReadonlyModelDefinition[];
+    refreshAvailableModels: (force?: boolean) => Promise<ReadonlyModelDefinition[]>;
+    credentialHints: CredentialHints;
+    authResolver: ReturnType<typeof createRuntimeAuthContext>["authResolver"];
+}
+export interface CliContextOptions {
+    cwd?: string;
+    startupMode?: "interactive" | "daemon";
+    skipDiscoveryRefresh?: boolean;
+}
+export declare function createCliContext(opts?: CliContextOptions): Promise<CliContext>;

package/dist/commands/arions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Arions command - Manage Arion personas
+ *
+ * Subcommands:
+ * - list: List all Arions with status
+ * - hatch: Create a new Arion
+ * - become: Switch to an Arion
+ * - retire: Retire an Arion
+ */
+import { Command } from "commander";
+/**
+ * Create the arions command group
+ */
+export declare function createArionsCommand(): Command;

package/dist/commands/auth.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Auth command - Manage auth profiles for multi-provider authentication
+ *
+ * Subcommands:
+ * - status: Show all auth profiles and their health
+ * - add: Add an API key for a provider
+ * - remove: Remove an auth profile
+ */
+import { Command } from "commander";
+/**
+ * Show all auth profiles, their type, health, and expiry.
+ */
+export declare function authStatusCommand(): Promise<void>;
+/**
+ * Interactively add an API key for a provider.
+ */
+export declare function authAddCommand(opts: {
+    provider: string;
+}): Promise<void>;
+/**
+ * Remove an auth profile by ID.
+ */
+export declare function authRemoveCommand(profileId: string): Promise<void>;
+/**
+ * Create the auth command group with status, add, and remove subcommands.
+ */
+export declare function createAuthCommand(): Command;

package/dist/commands/daemon.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Daemon command - monitor-style projection over the shared daemon service.
+ *
+ * The CLI wrapper only parses options, starts/stops the daemon via the
+ * canonical `daemon.*` service, prints human status lines, and stays resident
+ * until interrupted. It must not own runtime bootstrap semantics directly.
+ */
+import type { DaemonSafetyPolicy } from "@aria-cli/aria";
+export interface DaemonCliOptions {
+    arion?: string;
+    port?: string;
+    intervalMs?: string;
+    allowedToolCategories?: string;
+    allowedShellCommands?: string;
+    maxWriteOpsPerMinute?: string;
+    maxGitPushesPerHour?: string;
+}
+interface DaemonOptions {
+    arion?: string;
+    port: number;
+    intervalMs: number;
+    allowedToolCategories?: string[];
+    allowedShellCommands?: string[];
+    maxWriteOpsPerMinute?: number;
+    maxGitPushesPerHour?: number;
+}
+export declare function buildSafetyPolicy(options: DaemonOptions): DaemonSafetyPolicy;
+export declare function runDaemonFromCli(options?: DaemonCliOptions): Promise<void>;
+export declare function stopDaemonFromCli(): Promise<void>;
+export declare function restartDaemonFromCli(options?: DaemonCliOptions): Promise<void>;
+export {};

package/dist/commands/definitions.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Command definitions for the CLI
+ */
+export interface CommandDef {
+    name: string;
+    description: string;
+    usage?: string;
+    args?: string[];
+    requiresArgs?: boolean;
+}
+export declare const COMMANDS: CommandDef[];
+/**
+ * Get a command by name
+ */
+export declare function getCommand(name: string): CommandDef | undefined;
+/**
+ * Filter commands by prefix
+ */
+export declare function filterCommands(prefix: string): CommandDef[];