@mimir-labs/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SeaBassLab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,498 @@
+# Mimir CLI
+
+Reference implementation CLI for APS Protocol.
+
+[![npm version](https://img.shields.io/npm/v/%40mimir%2Fcli.svg)](https://www.npmjs.com/package/%40mimir/cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+
+Formal docs:
+
+- [APS Protocol Specification v1](./docs/specification.md)
+- [APS Protocol Rationale](./docs/rationale.md)
+
+## Introduction
+
+Software knowledge exists everywhere: component APIs, compatibility rules, lifecycle policies, usage constraints, and architectural conventions.
+
+Today, each library and platform documents that knowledge differently. The result is fragmented metadata that is hard to validate, hard to govern, and hard to consume across tools.
+
+Without an interoperable format, IDEs, automation pipelines, documentation generators, static analysis tools, and assistants must infer behavior from source code and prose.
+
+APS defines a software knowledge protocol for publishing structured software knowledge consistently. It standardizes how providers describe knowledge and how consumers validate, govern, and synchronize it.
+
+AI coding assistants are one possible consumer of APS knowledge, but APS is not limited to AI workflows.
+
+Traditional software packages publish:
+
+- Source code
+- Type definitions
+- Documentation
+
+APS providers additionally publish:
+
+- Structured software knowledge
+
+## What is APS?
+
+APS is an open protocol for publishing structured software knowledge.
+
+Like OpenAPI standardizes HTTP API descriptions and SPDX standardizes software bill-of-materials metadata, APS standardizes software knowledge artifacts and governance metadata.
+
+| Standard | Standardizes |
+|----------|--------------|
+| OpenAPI | HTTP APIs |
+| SPDX | Software bill of materials |
+| OCI | Container images |
+| APS | Software knowledge |
+
+APS is protocol-first:
+
+- Vendor-neutral and tooling-agnostic.
+- Designed for interoperability across ecosystems.
+- Compatible with package registries and private distribution channels.
+- Focused on machine-readable, reviewable, and governable knowledge artifacts.
+
+APS does not replace source code or human documentation. It complements them with a consistent protocol that automation and developer tooling can consume.
+
+## Why APS exists
+
+Software libraries already contain knowledge.
+
+That knowledge is spread across:
+
+- source code
+- README files
+- Storybook
+- Architecture Decision Records
+- wiki pages
+- onboarding documents
+- tribal knowledge
+
+APS gives software a single, structured, machine-readable representation of that knowledge.
+
+## Conceptual Model
+
+```text
+Source Code
+      |
+      v
+mimir generate
+      |
+      v
+APS Knowledge Base
+(Manifest + Resources)
+      |
+  +---+---+---+
+  |   |   |   |
+  v   v   v   v
+ IDE CI/CD AI Agents Runtime
+  |     |
+  v     v
+mimir sync Validation
+```
+
+## Core Concepts
+
+| Concept | Producer | Purpose |
+| --- | --- | --- |
+| Knowledge Provider | Library or platform package | Publishes structured software knowledge. |
+| Consumer | Application or platform toolchain | Consumes knowledge published by providers. |
+| Manifest | Knowledge Provider | Entry point of a provider package. |
+| Resource | Knowledge Provider | Knowledge unit such as a component, API, service, rule, or example. |
+| Governance | Knowledge Provider | Trust metadata covering provenance, evidence, lifecycle, applicability, and policy consistency. |
+| Adapter | Consumer environment | Converts APS knowledge into consumer-specific formats. |
+
+## Design Principles
+
+APS is designed around a few core principles.
+
+- Protocol-first
+- Tooling-agnostic
+- Incrementally adoptable
+- Evidence-based
+- Human-governed
+- Machine-readable
+
+## Why APS?
+
+APS benefits multiple consumers, not only assistants:
+
+- IDEs: enrich project context with structured, versioned knowledge.
+- Documentation generators: build consistent docs from protocol artifacts.
+- Static analysis: validate policy and compatibility metadata systematically.
+- Internal platforms: standardize publish/consume workflows across teams.
+- AI coding assistants: reduce inference ambiguity with explicit metadata.
+- Enterprise governance: enforce provenance, lifecycle, and policy consistency.
+
+## Who uses APS?
+
+APS has two primary personas.
+
+Providers:
+
+- Component libraries
+- SDKs
+- Backend frameworks
+- Internal platforms
+
+Consumers:
+
+- Application teams
+- Monorepos
+- Automation pipelines
+- IDE integrations
+- Documentation systems
+- Code assistants and AI agents
+
+## Installation
+
+Node.js 18+ is recommended.
+
+Global install:
+
+```bash
+npm install -g @mimir-labs/cli
+```
+
+Temporary execution:
+
+```bash
+npx @mimir-labs/cli --help
+```
+
+## Quick Start (Provider)
+
+Create your first APS Knowledge Provider:
+
+```bash
+cd my-library
+
+mimir init
+mimir generate
+
+# output
+# Generated:
+# ✓ manifest.json
+# ✓ components.json
+# ✓ rules.json
+#
+# Provider ready for validation.
+
+mimir validate
+mimir governance
+mimir doctor
+# publish provider package
+```
+
+Step summary:
+
+- `mimir init`: prepares APS configuration in package metadata.
+- `mimir generate`: scans your project and creates an initial APS knowledge base from observable evidence such as TypeScript exports, Storybook metadata, and package information.
+- `mimir validate`: verifies APS structural compliance.
+- `mimir governance`: validates governance metadata and policy consistency.
+- `mimir doctor`: evaluates maturity level before release.
+- Publish provider package: distributes the provider through a package registry.
+
+Human knowledge is intentionally left for later review.
+
+## Example
+
+Generated provider structure:
+
+```text
+dist/
+  aps/
+    manifest.json
+    components.json
+    rules.json
+    examples.json
+```
+
+Minimal APS manifest example:
+
+```json
+{
+  "version": 1,
+  "components": [
+    {
+      "type": "component",
+      "id": "acme.ui.component.button",
+      "name": "Button",
+      "package": "@acme/ui",
+      "import": "Button",
+      "description": "Primary action button"
+    }
+  ]
+}
+```
+
+## APS in Practice
+
+Provider project:
+
+```text
+my-ui-library/
+  dist/
+    aps/
+      manifest.json
+      components.json
+      rules.json
+      examples.json
+```
+
+Consumer project:
+
+```text
+consumer/
+  package.json
+
+npm install my-ui-library
+mimir discover
+mimir sync
+
+AGENTS.md generated
+```
+
+In practice, the provider publishes structured software knowledge once, and consumer projects discover and synchronize that knowledge into their local tooling context.
+
+## Provider Workflow
+
+```text
+mimir init
+  -> mimir generate
+  -> mimir validate
+  -> mimir governance
+  -> mimir doctor
+  -> Publish provider package
+```
+
+Why each step exists:
+
+- Generate -> creates machine-readable knowledge artifacts.
+- Validate -> ensures protocol compliance.
+- Governance -> ensures trust, provenance, and policy consistency.
+- Doctor -> evaluates provider maturity and release readiness.
+
+`mimir governance` validates governance metadata such as provenance, evidence, lifecycle, applicability and policy consistency.
+
+Governance makes APS knowledge trustworthy by validating where information comes from, how it is maintained, and whether it remains consistent over time.
+
+Use `mimir governance` when:
+
+- preparing a release that must meet internal trust or compliance standards
+- introducing new evidence sources or policy rules
+- verifying that governance metadata remains consistent after refactors
+
+Example:
+
+```bash
+mimir governance --json
+```
+
+## Consumer Workflow
+
+```text
+Install provider
+  -> mimir discover
+  -> mimir validate
+  -> mimir sync
+```
+
+Important:
+
+- `mimir sync` is not part of provider publication.
+- `mimir sync` belongs to the consumer side and synchronizes knowledge to adapters such as AGENTS.md, Copilot Instructions, Cursor Rules, and future integrations.
+
+Example:
+
+```text
+Consumer project
+
+mimir sync
+
+Generated
+
+✓ AGENTS.md
+✓ copilot-instructions.md
+✓ cursor-rules.mdc
+```
+
+Discovery example:
+
+```text
+$ mimir discover
+
+Found providers
+
+✓ @acme/ui
+  Components: 42
+  Rules: 18
+  Examples: 63
+```
+
+## Validate vs Governance
+
+`mimir validate` checks structural compliance.
+
+Typical checks include:
+
+- manifest shape
+- JSON validity
+- resource declarations
+- reference integrity
+
+`mimir governance` checks governance semantics.
+
+Definition:
+
+"Validates governance metadata such as provenance, evidence, lifecycle, applicability and policy consistency."
+
+Use `mimir governance` when:
+
+- preparing a release that must meet internal trust or compliance standards
+- introducing new evidence sources or policy rules
+- verifying that governance metadata remains consistent after refactors
+
+Example:
+
+```bash
+mimir governance --json
+```
+
+## Commands
+
+| Command | Role | Description | Example |
+| --- | --- | --- | --- |
+| `mimir init` | Provider | Initialize APS support in package metadata. | `mimir init` |
+| `mimir generate` | Provider | Generate APS resources from available evidence. | `mimir generate --force` |
+| `mimir discover` | Consumer | Discover APS-enabled dependencies/providers. | `mimir discover` |
+| `mimir validate` | Both | Validate APS manifest and declared resources. | `mimir validate` |
+| `mimir governance` | Provider | Validate provenance, evidence, lifecycle, applicability and policy consistency metadata. | `mimir governance --json` |
+| `mimir doctor` | Provider | Evaluate provider maturity (L0-L3). | `mimir doctor --json` |
+| `mimir sync` | Consumer | Synchronize discovered APS knowledge to configured consumer adapters. | `mimir sync` |
+| `mimir about` | Both | Show APS Protocol overview, workflows, and references. | `mimir about --json` |
+| `mimir help` | Both | Show command help and usage. | `mimir help governance` |
+| `mimir completion` | Utility | Print shell completion scripts. | `mimir completion zsh` |
+
+### Command Groups
+
+| Group | Commands |
+| --- | --- |
+| Provider Commands | `init`, `generate`, `validate`, `governance`, `doctor` |
+| Consumer Commands | `discover`, `sync` |
+| Utility Commands | `help`, `about`, `completion` |
+
+## Doctor
+
+The doctor command evaluates provider maturity and highlights gaps to reach stronger governance levels.
+
+Doctor is a release-readiness assessment, not a protocol validator.
+
+Example:
+
+```text
+$ mimir doctor
+
+Provider maturity: L2 (Governed)
+
+✔ Manifest
+✔ Resources
+✔ Provenance
+✔ Lifecycle
+
+Recommendation
+
+Complete ownership metadata to reach L3.
+```
+
+## Why not README, JSON Schema, or OpenAPI?
+
+| Technology | Primary purpose |
+| --- | --- |
+| README | Human documentation |
+| JSON Schema | Data shape validation |
+| OpenAPI | HTTP API description |
+| APS | Software knowledge exchange across providers and consumers |
+
+These technologies are complementary. APS does not replace them; it standardizes machine-readable software knowledge and governance metadata for interoperability.
+
+## Philosophy
+
+> Documentation is written for humans.
+>
+> APS artifacts are written for machines.
+>
+> Both are necessary.
+
+Documentation provides context and intent, while APS provides interoperable, machine-readable software knowledge for agents and automation tooling.
+
+## Roadmap
+
+### Protocol
+
+- [ ] Provider minimum contract
+- [ ] Governance profiles
+
+### CLI
+
+- [x] Discovery
+- [x] Validation
+- [x] Governance
+- [x] Generate v1
+
+### Reference Providers
+
+- [ ] React provider
+- [ ] Nest provider
+- [ ] Next provider
+- [ ] Vue provider
+- [ ] Angular provider
+- [ ] Express provider
+
+### Reference Consumers
+
+- [ ] AGENTS.md consumer adapter
+- [ ] Copilot Instructions consumer adapter
+- [ ] Cursor Rules consumer adapter
+
+### Registry
+
+- [ ] Private registries
+- [ ] Federated providers
+
+### Ecosystem
+
+- [ ] GitHub Action
+- [ ] VS Code Extension
+
+## FAQ
+
+**Does APS replace documentation?**
+
+No. APS complements documentation by adding structured software knowledge artifacts for automation and tooling.
+
+**Does APS require MCP?**
+
+No. APS is protocol-level and can be consumed with or without MCP.
+
+**Does APS work only with React?**
+
+No. APS is technology-agnostic and can model frontend and backend knowledge.
+
+**Can I use APS in backend projects?**
+
+Yes. APS supports broader resource families and backend-oriented governance patterns.
+
+**Can I publish private providers?**
+
+Yes. Providers can be distributed privately, including internal registries and private package infrastructures.
+
+## Contributing
+
+Contributions are welcome. Open an issue for proposals or submit a pull request with a focused change and clear rationale.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function runCli(argv: string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const context_1 = require("./commands/context");
+const discover_1 = require("./commands/discover");
+const generate_1 = require("./commands/generate");
+const governance_1 = require("./commands/governance");
+const init_1 = require("./commands/init");
+const sync_1 = require("./commands/sync");
+const validate_1 = require("./commands/validate");
+const doctor_1 = require("./commands/doctor");
+const command_1 = require("./dx/help/command");
+const command_2 = require("./dx/completion/command");
+const constants_1 = require("./dx/branding/constants");
+const command_3 = require("./dx/about/command");
+const options_1 = require("./dx/runtime/options");
+async function runCli(argv) {
+    (0, options_1.configureRuntimeOptions)(argv);
+    const program = new commander_1.Command();
+    program
+        .name(constants_1.CLI_BINARY_NAME)
+        .description(`Reference implementation CLI for the ${constants_1.CLI_PROTOCOL_NAME}`)
+        .version("1.0.0");
+    program.option("--json", "Emit deterministic JSON output");
+    program.option("--verbose", "Enable verbose output");
+    program.option("--quiet", "Suppress non-error output");
+    program.option("--dry-run", "Show planned actions without changing files");
+    program.showSuggestionAfterError(true);
+    program.showHelpAfterError();
+    program.helpCommand(false);
+    (0, init_1.registerInitCommand)(program);
+    (0, discover_1.registerDiscoverCommand)(program);
+    (0, context_1.registerContextCommand)(program);
+    (0, validate_1.registerValidateCommand)(program);
+    (0, governance_1.registerGovernanceCommand)(program);
+    (0, doctor_1.registerDoctorCommand)(program);
+    (0, generate_1.registerGenerateCommand)(program);
+    (0, sync_1.registerSyncCommand)(program);
+    (0, command_3.registerAboutCommand)(program);
+    (0, command_2.registerCompletionCommand)(program);
+    (0, command_1.registerHelpCommand)(program);
+    await program.parseAsync(argv);
+}
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";;AAeA,wBAgCC;AA/CD,yCAAoC;AACpC,gDAA4D;AAC5D,kDAA8D;AAC9D,kDAA8D;AAC9D,sDAAkE;AAClE,0CAAsD;AACtD,0CAAsD;AACtD,kDAA8D;AAC9D,8CAA0D;AAC1D,+CAAwD;AACxD,qDAAoE;AACpE,uDAA6E;AAC7E,gDAA0D;AAC1D,kDAA+D;AAExD,KAAK,UAAU,MAAM,CAAC,IAAc;IACzC,IAAA,iCAAuB,EAAC,IAAI,CAAC,CAAC;IAE9B,MAAM,OAAO,GAAG,IAAI,mBAAO,EAAE,CAAC;IAE9B,OAAO;SACJ,IAAI,CAAC,2BAAe,CAAC;SACrB,WAAW,CAAC,wCAAwC,6BAAiB,EAAE,CAAC;SACxE,OAAO,CAAC,OAAO,CAAC,CAAC;IAEpB,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,gCAAgC,CAAC,CAAC;IAC3D,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,uBAAuB,CAAC,CAAC;IACrD,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,2BAA2B,CAAC,CAAC;IACvD,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,6CAA6C,CAAC,CAAC;IAC3E,OAAO,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC;IACvC,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAE7B,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAE3B,IAAA,0BAAmB,EAAC,OAAO,CAAC,CAAC;IAC7B,IAAA,kCAAuB,EAAC,OAAO,CAAC,CAAC;IACjC,IAAA,gCAAsB,EAAC,OAAO,CAAC,CAAC;IAChC,IAAA,kCAAuB,EAAC,OAAO,CAAC,CAAC;IACjC,IAAA,sCAAyB,EAAC,OAAO,CAAC,CAAC;IACnC,IAAA,8BAAqB,EAAC,OAAO,CAAC,CAAC;IAC/B,IAAA,kCAAuB,EAAC,OAAO,CAAC,CAAC;IACjC,IAAA,0BAAmB,EAAC,OAAO,CAAC,CAAC;IAC7B,IAAA,8BAAoB,EAAC,OAAO,CAAC,CAAC;IAC9B,IAAA,mCAAyB,EAAC,OAAO,CAAC,CAAC;IACnC,IAAA,6BAAmB,EAAC,OAAO,CAAC,CAAC;IAE7B,MAAM,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC"}

package/dist/commands/context.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerContextCommand(program: Command): void;

package/dist/commands/context.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerContextCommand = registerContextCommand;
+const core_1 = require("@mimir-labs/core");
+const attach_command_help_1 = require("../dx/help/attach-command-help");
+const cli_output_1 = require("../dx/output/cli-output");
+const options_1 = require("../dx/runtime/options");
+function registerContextCommand(program) {
+    const command = program
+        .command("context")
+        .description("Generate AI agent context from discovered APS packages")
+        .option("--json", "Emit machine-readable context result")
+        .action(async (options) => {
+        try {
+            if ((0, options_1.isDryRun)()) {
+                const payload = {
+                    command: "context",
+                    dryRun: true,
+                    ok: true,
+                    plan: ["discover providers", "generate context files", "update AGENTS.md managed section"]
+                };
+                if ((0, options_1.shouldEmitJson)(options.json)) {
+                    (0, cli_output_1.printJson)(payload);
+                }
+                else {
+                    (0, cli_output_1.success)("dry-run: would generate context files and update AGENTS.md");
+                }
+                return;
+            }
+            const result = await (0, core_1.runContextWorkflow)(process.cwd());
+            if ((0, options_1.shouldEmitJson)(options.json)) {
+                (0, cli_output_1.printJson)({ command: "context", ok: true, result });
+                return;
+            }
+            (0, cli_output_1.success)(`context generated in ${result.outputDir}`);
+            for (const file of result.files) {
+                console.log(`- ${file}`);
+            }
+            (0, cli_output_1.success)("AGENTS.md updated with APS managed section");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if ((0, options_1.shouldEmitJson)(options.json)) {
+                (0, cli_output_1.printJson)({ command: "context", ok: false, error: message });
+            }
+            else {
+                (0, cli_output_1.errorMessage)(`context generation failed: ${message}`);
+            }
+            (0, cli_output_1.setExitCode)(cli_output_1.EXIT_CODES.GENERAL_ERROR);
+        }
+    });
+    (0, attach_command_help_1.attachCommandHelp)(command, "context");
+}
+//# sourceMappingURL=context.js.map

package/dist/commands/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/commands/context.ts"],"names":[],"mappings":";;AAYA,wDA8CC;AAzDD,2CAAsD;AACtD,wEAAmE;AACnE,wDAMiC;AACjC,mDAAiE;AAEjE,SAAgB,sBAAsB,CAAC,OAAgB;IACrD,MAAM,OAAO,GAAG,OAAO;SACpB,OAAO,CAAC,SAAS,CAAC;SAClB,WAAW,CAAC,wDAAwD,CAAC;SACrE,MAAM,CAAC,QAAQ,EAAE,sCAAsC,CAAC;SACxD,MAAM,CAAC,KAAK,EAAE,OAA2B,EAAE,EAAE;QAC5C,IAAI,CAAC;YACH,IAAI,IAAA,kBAAQ,GAAE,EAAE,CAAC;gBACf,MAAM,OAAO,GAAG;oBACd,OAAO,EAAE,SAAS;oBAClB,MAAM,EAAE,IAAI;oBACZ,EAAE,EAAE,IAAI;oBACR,IAAI,EAAE,CAAC,oBAAoB,EAAE,wBAAwB,EAAE,kCAAkC,CAAC;iBAC3F,CAAC;gBACF,IAAI,IAAA,wBAAc,EAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;oBACjC,IAAA,sBAAS,EAAC,OAAO,CAAC,CAAC;gBACrB,CAAC;qBAAM,CAAC;oBACN,IAAA,oBAAO,EAAC,4DAA4D,CAAC,CAAC;gBACxE,CAAC;gBACD,OAAO;YACT,CAAC;YAED,MAAM,MAAM,GAAG,MAAM,IAAA,yBAAkB,EAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;YAEvD,IAAI,IAAA,wBAAc,EAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;gBACjC,IAAA,sBAAS,EAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;gBACpD,OAAO;YACT,CAAC;YAED,IAAA,oBAAO,EAAC,wBAAwB,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;YACpD,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBAChC,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;YAC3B,CAAC;YACD,IAAA,oBAAO,EAAC,4CAA4C,CAAC,CAAC;QACxD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACvE,IAAI,IAAA,wBAAc,EAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;gBACjC,IAAA,sBAAS,EAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;YAC/D,CAAC;iBAAM,CAAC;gBACN,IAAA,yBAAY,EAAC,8BAA8B,OAAO,EAAE,CAAC,CAAC;YACxD,CAAC;YACD,IAAA,wBAAW,EAAC,uBAAU,CAAC,aAAa,CAAC,CAAC;QACxC,CAAC;IACH,CAAC,CAAC,CAAC;IAEL,IAAA,uCAAiB,EAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AACxC,CAAC"}

package/dist/commands/discover.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerDiscoverCommand(program: Command): void;