@enactprotocol/cli 2.1.7 → 2.1.10

package/src/commands/init/index.ts

@@ -26,7 +26,7 @@ const SUPABASE_ANON_KEY =
  * Embedded templates (for single-binary compatibility)
  */
 const TEMPLATES: Record<string, string> = {
-  "tool-enact.md": `---
+  "tool-skill.md": `---
 name: {{TOOL_NAME}}
 description: A simple tool that echoes a greeting
 version: 0.1.0
@@ -74,7 +74,7 @@ Edit this file to create your own tool:
 
   "tool-agents.md": `# Enact Tool Development Guide
 
-Enact tools are containerized, cryptographically-signed executables. Each tool is defined by an \`enact.md\` file (YAML frontmatter + Markdown docs).
+Enact tools are containerized, cryptographically-signed executables. Each tool is defined by a \`SKILL.md\` file (YAML frontmatter + Markdown docs).
 
 ## Quick Reference
 
@@ -85,7 +85,7 @@ Enact tools are containerized, cryptographically-signed executables. Each tool i
 | Dry run | \`enact run ./ --args '{}' --dry-run\` |
 | Sign & publish | \`enact sign ./ && enact publish ./\` |
 
-## enact.md Structure
+## SKILL.md Structure
 
 \`\`\`yaml
 ---
@@ -225,7 +225,7 @@ Tools run in a container with \`/work\` as the working directory. All source fil
 
 ## Secrets
 
-Declare in \`enact.md\`:
+Declare in \`SKILL.md\`:
 \`\`\`yaml
 env:
   API_KEY:
@@ -302,6 +302,7 @@ enact run ./path/to/tool --args '{}'              # Run local tool
 \`\`\`bash
 enact search "pdf extraction"                     # Search registry
 enact get author/category/tool                    # View tool info
+enact learn author/category/tool                  # View tool documentation
 enact install author/category/tool                # Add to project (.enact/tools.json)
 enact install author/category/tool --global       # Add globally
 enact list                                        # List project tools
@@ -314,7 +315,7 @@ enact run tool --args '{}' | jq '.result'
 \`\`\`
 
 ## Creating Local Tools
-Create \`tools/<name>/enact.md\` with:
+Create \`tools/<name>/SKILL.md\` with:
 \`\`\`yaml
 ---
 name: my-tool
@@ -345,6 +346,7 @@ This project uses Enact tools — containerized, signed executables you can run
 \`\`\`bash
 enact run <tool> --args '{"key": "value"}'   # Run a tool
 enact search "keyword"                        # Find tools
+enact learn author/tool                       # View tool documentation
 enact install author/tool                     # Install tool
 enact list                                    # List installed tools
 \`\`\`
@@ -360,7 +362,7 @@ enact run tool --args '{}' | jq '.data'
 \`\`\`
 
 ## Creating Tools
-Create \`enact.md\` in a directory:
+Create \`SKILL.md\` in a directory:
 \`\`\`yaml
 ---
 name: namespace/category/tool
@@ -394,7 +396,7 @@ enact sign ./ && enact publish ./             # Publish
 \`\`\`
 
 ## Secrets
-Declare in enact.md, set via CLI:
+Declare in SKILL.md, set via CLI:
 \`\`\`yaml
 env:
   API_KEY:    # Declared but not set
@@ -543,9 +545,9 @@ async function initHandler(options: InitOptions, ctx: CommandContext): Promise<v
   const isClaudeMode = options.claude;
   // Default to agent mode if no flag specified
 
-  // Handle --tool mode: create enact.md + AGENTS.md for tool development
+  // Handle --tool mode: create SKILL.md + AGENTS.md for tool development
   if (isToolMode) {
-    const manifestPath = join(targetDir, "enact.md");
+    const manifestPath = join(targetDir, "SKILL.md");
     const agentsPath = join(targetDir, "AGENTS.md");
 
     if (existsSync(manifestPath) && !options.force) {
@@ -571,7 +573,7 @@ async function initHandler(options: InitOptions, ctx: CommandContext): Promise<v
 
     // Load templates with placeholder replacement
     const replacements = { TOOL_NAME: toolName };
-    const manifestContent = loadTemplate("tool-enact.md", replacements);
+    const manifestContent = loadTemplate("tool-skill.md", replacements);
     const agentsContent = loadTemplate("tool-agents.md", replacements);
 
     // Ensure directory exists
@@ -579,7 +581,7 @@ async function initHandler(options: InitOptions, ctx: CommandContext): Promise<v
       mkdirSync(targetDir, { recursive: true });
     }
 
-    // Write enact.md
+    // Write SKILL.md
     writeFileSync(manifestPath, manifestContent, "utf-8");
     success(`Created tool manifest: ${manifestPath}`);
 
@@ -593,7 +595,7 @@ async function initHandler(options: InitOptions, ctx: CommandContext): Promise<v
 
     info("");
     info("Next steps:");
-    info("  1. Edit enact.md to customize your tool");
+    info("  1. Edit SKILL.md to customize your tool");
     info("  2. Run 'enact run ./' to test your tool");
     info("  3. Run 'enact publish' to share your tool");
     return;
@@ -637,7 +639,8 @@ async function initHandler(options: InitOptions, ctx: CommandContext): Promise<v
 
   info("");
   info("This file helps AI agents understand how to use Enact tools in your project.");
-  info("Run 'enact search <query>' to find tools, 'enact install <tool>' to add them.");
+  info("Run 'enact search <query>' to find tools, 'enact learn <tool>' to view docs,");
+  info("and 'enact install <tool>' to add them.");
 }
 
 /**
@@ -649,7 +652,7 @@ export function configureInitCommand(program: Command): void {
     .description("Initialize Enact in the current directory")
     .option("-n, --name <name>", "Tool name (default: username/my-tool)")
     .option("-f, --force", "Overwrite existing files")
-    .option("--tool", "Create a new Enact tool (enact.md + AGENTS.md)")
+    .option("--tool", "Create a new Enact tool (SKILL.md + AGENTS.md)")
     .option("--agent", "Create AGENTS.md + .enact/tools.json (default)")
     .option("--claude", "Create CLAUDE.md + .enact/tools.json")
     .option("-v, --verbose", "Show detailed output")

package/src/commands/learn/index.ts

@@ -3,16 +3,46 @@
  *
  * Display the documentation (enact.md) for a tool.
  * Fetches and displays the raw manifest content for easy reading.
+ *
+ * Security: For tools fetched from the registry, attestation checks are
+ * performed according to the trust policy. This prevents potentially
+ * malicious documentation from being displayed to LLMs or users.
  */
 
-import { createApiClient, getToolInfo, getToolVersion } from "@enactprotocol/api";
-import { loadConfig } from "@enactprotocol/shared";
+import {
+  type AttestationListResponse,
+  createApiClient,
+  getAttestationList,
+  getToolInfo,
+  getToolVersion,
+  verifyAllAttestations,
+} from "@enactprotocol/api";
+import {
+  getMinimumAttestations,
+  getTrustPolicy,
+  getTrustedAuditors,
+  loadConfig,
+  tryResolveTool,
+} from "@enactprotocol/shared";
 import type { Command } from "commander";
 import type { CommandContext, GlobalOptions } from "../../types";
-import { dim, error, formatError, header, json, newline } from "../../utils";
+import {
+  TrustError,
+  confirm,
+  dim,
+  error,
+  formatError,
+  header,
+  info,
+  json,
+  newline,
+  success,
+  symbols,
+} from "../../utils";
 
 interface LearnOptions extends GlobalOptions {
   ver?: string;
+  local?: boolean;
 }
 
 /**
@@ -21,14 +51,76 @@ interface LearnOptions extends GlobalOptions {
 async function learnHandler(
   toolName: string,
   options: LearnOptions,
-  _ctx: CommandContext
+  ctx: CommandContext
 ): Promise<void> {
+  // First, try to resolve locally (project → user → cache)
+  // If the tool is already installed/cached, we trust it
+  const resolution = tryResolveTool(toolName, { startDir: ctx.cwd });
+
+  if (resolution) {
+    // Tool is installed locally - read documentation from the manifest file
+    if (resolution.manifestPath.endsWith(".md")) {
+      const { readFileSync } = await import("node:fs");
+      const content = readFileSync(resolution.manifestPath, "utf-8");
+
+      if (options.json) {
+        json({
+          name: toolName,
+          version: resolution.manifest.version,
+          documentation: content,
+          source: "local",
+        });
+        return;
+      }
+
+      header(`${toolName}@${resolution.manifest.version ?? "local"}`);
+      dim("(installed locally)");
+      newline();
+      console.log(content);
+      return;
+    }
+
+    // Fallback for non-.md manifests
+    if (options.json) {
+      json({
+        name: toolName,
+        version: resolution.manifest.version,
+        documentation: resolution.manifest.doc ?? resolution.manifest.description ?? null,
+        source: "local",
+      });
+      return;
+    }
+
+    header(`${toolName}@${resolution.manifest.version ?? "local"}`);
+    dim("(installed locally)");
+    newline();
+    console.log(
+      resolution.manifest.doc ?? resolution.manifest.description ?? "No documentation available."
+    );
+    return;
+  }
+
+  // If --local flag is set, don't fetch from registry
+  if (options.local) {
+    error(`Tool not found locally: ${toolName}`);
+    dim("The tool is not installed. Remove --local to fetch from registry.");
+    process.exit(1);
+  }
+
+  // Tool not installed - fetch from registry with attestation checks
   const config = loadConfig();
   const registryUrl =
     process.env.ENACT_REGISTRY_URL ??
     config.registry?.url ??
     "https://siikwkfgsmouioodghho.supabase.co/functions/v1";
-  const authToken = config.registry?.authToken;
+
+  // Get auth token - use user token if available, otherwise use anon key for public access
+  let authToken = config.registry?.authToken ?? process.env.ENACT_AUTH_TOKEN;
+  if (!authToken && registryUrl.includes("siikwkfgsmouioodghho.supabase.co")) {
+    authToken =
+      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InNpaWt3a2Znc21vdWlvb2RnaGhvIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjQ2MTkzMzksImV4cCI6MjA4MDE5NTMzOX0.kxnx6-IPFhmGx6rzNx36vbyhFMFZKP_jFqaDbKnJ_E0";
+  }
+
   const client = createApiClient({
     baseUrl: registryUrl,
     authToken: authToken,
@@ -42,14 +134,139 @@ async function learnHandler(
       version = toolInfo.latestVersion;
     }
 
+    if (!version) {
+      error(`No published versions for ${toolName}`);
+      process.exit(1);
+    }
+
     // Get the version info which includes rawManifest
     const versionInfo = await getToolVersion(client, toolName, version);
 
+    // ========================================
+    // TRUST VERIFICATION - same as run command
+    // ========================================
+    const trustPolicy = getTrustPolicy();
+    const minimumAttestations = getMinimumAttestations();
+    const trustedAuditors = getTrustedAuditors();
+
+    // Fetch attestations from registry
+    const attestationsResponse: AttestationListResponse = await getAttestationList(
+      client,
+      toolName,
+      version
+    );
+    const attestations = attestationsResponse.attestations;
+
+    if (attestations.length === 0) {
+      // No attestations found
+      info(`${symbols.warning} Tool ${toolName}@${version} has no attestations.`);
+
+      if (trustPolicy === "require_attestation") {
+        throw new TrustError(
+          "Trust policy requires attestations. Cannot display documentation from unverified tools."
+        );
+      }
+      if (ctx.isInteractive && trustPolicy === "prompt") {
+        dim("Documentation from unverified tools may contain malicious content.");
+        const proceed = await confirm("View documentation from unverified tool?");
+        if (!proceed) {
+          info("Cancelled.");
+          process.exit(0);
+        }
+      } else if (!ctx.isInteractive && trustPolicy === "prompt") {
+        throw new TrustError(
+          "Cannot display documentation from unverified tools in non-interactive mode."
+        );
+      }
+      // trustPolicy === "allow" - continue without prompting
+    } else {
+      // Verify attestations locally (never trust registry's verification status)
+      const verifiedAuditors = await verifyAllAttestations(
+        client,
+        toolName,
+        version,
+        versionInfo.bundle.hash ?? ""
+      );
+
+      // Check verified auditors against trust config using provider:identity format
+      const trustedVerifiedAuditors = verifiedAuditors
+        .filter((auditor) => trustedAuditors.includes(auditor.providerIdentity))
+        .map((auditor) => auditor.providerIdentity);
+
+      if (trustedVerifiedAuditors.length > 0) {
+        // Check if we meet minimum attestations threshold
+        if (trustedVerifiedAuditors.length < minimumAttestations) {
+          info(
+            `${symbols.warning} Tool ${toolName}@${version} has ${trustedVerifiedAuditors.length} trusted attestation(s), but ${minimumAttestations} required.`
+          );
+          dim(`Trusted attestations: ${trustedVerifiedAuditors.join(", ")}`);
+
+          if (trustPolicy === "require_attestation") {
+            throw new TrustError(
+              `Trust policy requires at least ${minimumAttestations} attestation(s) from trusted identities.`
+            );
+          }
+          if (ctx.isInteractive && trustPolicy === "prompt") {
+            const proceed = await confirm(
+              "View documentation with fewer attestations than required?"
+            );
+            if (!proceed) {
+              info("Cancelled.");
+              process.exit(0);
+            }
+          } else if (!ctx.isInteractive && trustPolicy === "prompt") {
+            throw new TrustError(
+              "Cannot display documentation without meeting minimum attestation requirement in non-interactive mode."
+            );
+          }
+          // trustPolicy === "allow" - continue without prompting
+        } else {
+          // Tool meets or exceeds minimum attestations
+          if (options.verbose) {
+            success(
+              `Tool verified by ${trustedVerifiedAuditors.length} trusted identity(ies): ${trustedVerifiedAuditors.join(", ")}`
+            );
+          }
+        }
+      } else {
+        // Has attestations but none from trusted auditors
+        info(
+          `${symbols.warning} Tool ${toolName}@${version} has ${verifiedAuditors.length} attestation(s), but none from trusted auditors.`
+        );
+
+        if (trustPolicy === "require_attestation") {
+          dim(`Your trusted auditors: ${trustedAuditors.join(", ")}`);
+          dim(`Tool attested by: ${verifiedAuditors.map((a) => a.providerIdentity).join(", ")}`);
+          throw new TrustError(
+            "Trust policy requires attestations from trusted identities. Cannot display documentation."
+          );
+        }
+        if (ctx.isInteractive && trustPolicy === "prompt") {
+          dim(`Attested by: ${verifiedAuditors.map((a) => a.providerIdentity).join(", ")}`);
+          dim(`Your trusted auditors: ${trustedAuditors.join(", ")}`);
+          const proceed = await confirm("View documentation anyway?");
+          if (!proceed) {
+            info("Cancelled.");
+            process.exit(0);
+          }
+        } else if (!ctx.isInteractive && trustPolicy === "prompt") {
+          throw new TrustError(
+            "Cannot display documentation without trusted attestations in non-interactive mode."
+          );
+        }
+        // trustPolicy === "allow" - continue without prompting
+      }
+    }
+
+    // ========================================
+    // Display documentation (trust verified)
+    // ========================================
     if (options.json) {
       json({
         name: toolName,
         version: versionInfo.version,
         documentation: versionInfo.rawManifest ?? null,
+        source: "registry",
       });
       return;
     }
@@ -65,6 +282,10 @@ async function learnHandler(
     newline();
     console.log(versionInfo.rawManifest);
   } catch (err) {
+    if (err instanceof TrustError) {
+      error(err.message);
+      process.exit(1);
+    }
     if (err instanceof Error) {
       if (err.message.includes("not_found") || err.message.includes("404")) {
         error(`Tool not found: ${toolName}`);
@@ -88,7 +309,9 @@ export function configureLearnCommand(program: Command): void {
     .command("learn <tool>")
     .description("Display documentation (enact.md) for a tool")
     .option("--ver <version>", "Show documentation for a specific version")
+    .option("--local", "Only show documentation for locally installed tools")
     .option("--json", "Output as JSON")
+    .option("-v, --verbose", "Show detailed output")
     .action(async (toolName: string, options: LearnOptions) => {
       const ctx: CommandContext = {
         cwd: process.cwd(),

package/src/commands/publish/index.ts

@@ -130,9 +130,16 @@ async function createBundleFromDir(toolDir: string): Promise<Uint8Array> {
 }
 
 /**
- * Load the raw enact.md file content (full documentation with frontmatter)
+ * Load the raw markdown manifest file content (full documentation with frontmatter)
+ * Checks for SKILL.md first (preferred), then falls back to enact.md
  */
-function loadEnactMd(toolDir: string): string | undefined {
+function loadRawManifest(toolDir: string): string | undefined {
+  // Check SKILL.md first (preferred format)
+  const skillMdPath = join(toolDir, "SKILL.md");
+  if (existsSync(skillMdPath)) {
+    return readFileSync(skillMdPath, "utf-8");
+  }
+  // Fall back to enact.md
   const enactMdPath = join(toolDir, "enact.md");
   if (existsSync(enactMdPath)) {
     return readFileSync(enactMdPath, "utf-8");
@@ -299,10 +306,10 @@ async function publishHandler(
     return;
   }
 
-  // Load the full enact.md content (frontmatter + documentation)
-  const enactMdContent = loadEnactMd(toolDir);
-  if (enactMdContent) {
-    info("Found enact.md documentation");
+  // Load the full markdown manifest content (SKILL.md or enact.md)
+  const rawManifestContent = loadRawManifest(toolDir);
+  if (rawManifestContent) {
+    info("Found markdown documentation (SKILL.md or enact.md)");
   }
 
   // Create bundle
@@ -318,7 +325,7 @@ async function publishHandler(
       name: toolName,
       manifest: manifest as unknown as Record<string, unknown>,
       bundle,
-      rawManifest: enactMdContent,
+      rawManifest: rawManifestContent,
     });
   });
 

package/src/commands/sign/index.ts

@@ -7,12 +7,18 @@
  *
  * Supports both local paths and remote tool references:
  *   - Local: enact sign ./my-tool
- *   - Remote: enact sign author/tool@1.0.0
+ *   - Remote: enact sign author/tool         (prompts for version)
+ *   - Remote: enact sign author/tool@1.0.0   (specific version)
  */
 
 import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { createApiClient, getToolVersion, submitAttestationToRegistry } from "@enactprotocol/api";
+import {
+  createApiClient,
+  getToolInfo,
+  getToolVersion,
+  submitAttestationToRegistry,
+} from "@enactprotocol/api";
 import { getSecret } from "@enactprotocol/secrets";
 import {
   addTrustedAuditor,
@@ -42,6 +48,7 @@ import {
   json,
   keyValue,
   newline,
+  select,
   success,
   symbols,
   warning,
@@ -63,26 +70,37 @@ interface SignOptions extends GlobalOptions {
 const DEFAULT_BUNDLE_FILENAME = ".sigstore-bundle.json";
 
 /**
- * Parse a remote tool reference like "author/tool@1.0.0"
- * Returns null if not a valid remote reference
+ * Parse a remote tool reference like "author/tool@1.0.0" or "author/tool"
+ * Version is optional - if not provided, will prompt user to select
+ * Returns null if not a valid remote reference (i.e., looks like a local path)
  */
-function parseRemoteToolRef(ref: string): { name: string; version: string } | null {
+function parseRemoteToolRef(ref: string): { name: string; version: string | undefined } | null {
   // Remote refs look like: author/tool@version or org/author/tool@version
-  // They don't start with . or / and contain @ for version
+  // They don't start with . or / and must contain at least one /
   if (ref.startsWith(".") || ref.startsWith("/") || ref.startsWith("~")) {
     return null;
   }
 
+  // Must have at least one / in the name (author/tool format)
+  if (!ref.includes("/")) {
+    return null;
+  }
+
   const atIndex = ref.lastIndexOf("@");
-  if (atIndex === -1 || atIndex === 0) {
+  if (atIndex === -1) {
+    // No version specified - that's OK, we'll prompt for it
+    return { name: ref, version: undefined };
+  }
+
+  if (atIndex === 0) {
     return null;
   }
 
   const name = ref.substring(0, atIndex);
   const version = ref.substring(atIndex + 1);
 
-  // Must have at least one / in the name (author/tool)
-  if (!name.includes("/") || !version) {
+  // Version after @ must not be empty
+  if (!version) {
     return null;
   }
 
@@ -276,9 +294,9 @@ function displayResult(
  * Sign a remote tool from the registry
  */
 async function signRemoteTool(
-  toolRef: { name: string; version: string },
+  toolRef: { name: string; version: string | undefined },
   options: SignOptions,
-  _ctx: CommandContext
+  ctx: CommandContext
 ): Promise<void> {
   const config = loadConfig();
   const registryUrl =
@@ -308,14 +326,71 @@ async function signRemoteTool(
     newline();
   }
 
+  // Resolve version - prompt if not provided
+  let targetVersion = toolRef.version;
+
+  if (!targetVersion) {
+    // Fetch tool info to get available versions
+    info(`Fetching versions for ${toolRef.name}...`);
+
+    let toolMetadata: Awaited<ReturnType<typeof getToolInfo>>;
+    try {
+      toolMetadata = await getToolInfo(client, toolRef.name);
+    } catch (err) {
+      error(`Tool not found: ${toolRef.name}`);
+      if (err instanceof Error) {
+        dim(`  ${err.message}`);
+      }
+      process.exit(1);
+    }
+
+    if (toolMetadata.versions.length === 0) {
+      error(`No published versions found for ${toolRef.name}`);
+      process.exit(1);
+    }
+
+    // Filter out yanked versions for selection (unless there are no non-yanked versions)
+    const availableVersions = toolMetadata.versions.filter((v) => !v.yanked);
+    const versionsToShow = availableVersions.length > 0 ? availableVersions : toolMetadata.versions;
+
+    if (ctx.isInteractive) {
+      // Prompt user to select a version
+      newline();
+      const selectedVersion = await select(
+        "Select a version to sign:",
+        versionsToShow.map((v) => {
+          const option: { value: string; label: string; hint?: string } = {
+            value: v.version,
+            label: v.version + (v.version === toolMetadata.latestVersion ? " (latest)" : ""),
+          };
+          if (v.yanked) {
+            option.hint = "yanked";
+          }
+          return option;
+        })
+      );
+
+      if (!selectedVersion) {
+        info("Signing cancelled");
+        return;
+      }
+
+      targetVersion = selectedVersion;
+    } else {
+      // Non-interactive: use latest version
+      targetVersion = toolMetadata.latestVersion;
+      info(`Using latest version: ${targetVersion}`);
+    }
+  }
+
   // Fetch tool info from registry
-  info(`Fetching ${toolRef.name}@${toolRef.version} from registry...`);
+  info(`Fetching ${toolRef.name}@${targetVersion} from registry...`);
 
   let toolInfo: Awaited<ReturnType<typeof getToolVersion>>;
   try {
-    toolInfo = await getToolVersion(client, toolRef.name, toolRef.version);
+    toolInfo = await getToolVersion(client, toolRef.name, targetVersion);
   } catch (err) {
-    error(`Tool not found: ${toolRef.name}@${toolRef.version}`);
+    error(`Tool not found: ${toolRef.name}@${targetVersion}`);
     if (err instanceof Error) {
       dim(`  ${err.message}`);
     }
@@ -357,7 +432,7 @@ async function signRemoteTool(
   }
 
   // Confirm signing
-  if (_ctx.isInteractive) {
+  if (ctx.isInteractive) {
     newline();
     const shouldSign = await confirm(
       `Sign ${toolInfo.name}@${toolInfo.version} with your identity?`,
@@ -466,10 +541,10 @@ async function signRemoteTool(
     }
 
     // Prompt to add to trust list - extract issuer from bundle for correct identity format
-    if (_ctx.isInteractive && !options.json) {
+    if (ctx.isInteractive && !options.json) {
       const certificate = extractCertificateFromBundle(result.bundle);
       const issuer = certificate?.identity?.issuer;
-      await promptAddToTrustList(attestationResult.auditor, _ctx.isInteractive, issuer);
+      await promptAddToTrustList(attestationResult.auditor, ctx.isInteractive, issuer);
     }
 
     if (options.json) {
@@ -719,7 +794,7 @@ export function configureSignCommand(program: Command): void {
     .description("Cryptographically sign a tool and submit attestation to registry")
     .argument(
       "<path>",
-      "Path to tool directory, manifest file, or remote tool (author/tool@version)"
+      "Path to tool directory, manifest file, or remote tool (author/tool or author/tool@version)"
     )
     .option("-i, --identity <email>", "Sign with specific identity (uses OAuth)")
     .option("-o, --output <path>", "Output path for signature bundle (local only)")

package/src/index.ts

@@ -15,7 +15,7 @@ import {
   configureConfigCommand,
   configureEnvCommand,
   configureExecCommand,
-  configureGetCommand,
+  configureInfoCommand,
   configureInitCommand,
   configureInspectCommand,
   configureInstallCommand,
@@ -33,7 +33,7 @@ import {
 } from "./commands";
 import { error, formatError } from "./utils";
 
-export const version = "2.1.7";
+export const version = "2.1.10";
 
 // Export types for external use
 export type { GlobalOptions, CommandContext } from "./types";
@@ -63,7 +63,7 @@ async function main() {
 
   // Registry commands (Phase 8)
   configureSearchCommand(program);
-  configureGetCommand(program);
+  configureInfoCommand(program);
   configureLearnCommand(program);
   configurePublishCommand(program);
   configureAuthCommand(program);