@enactprotocol/cli 2.1.6 → 2.1.10

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.6";
+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);

package/tests/commands/{get.test.ts → info.test.ts}

@@ -1,64 +1,66 @@
 /**
- * Tests for the get command
+ * Tests for the info command
  */
 
 import { describe, expect, test } from "bun:test";
 import type { ToolVersionInfo } from "@enactprotocol/api";
 import { Command } from "commander";
-import { configureGetCommand } from "../../src/commands/get";
+import { configureInfoCommand } from "../../src/commands/info";
 
-describe("get command", () => {
+describe("info command", () => {
   describe("command configuration", () => {
-    test("configures get command on program", () => {
+    test("configures info command on program", () => {
       const program = new Command();
-      configureGetCommand(program);
+      configureInfoCommand(program);
 
-      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
-      expect(getCmd).toBeDefined();
+      const infoCmd = program.commands.find((cmd) => cmd.name() === "info");
+      expect(infoCmd).toBeDefined();
     });
 
     test("has correct description", () => {
       const program = new Command();
-      configureGetCommand(program);
+      configureInfoCommand(program);
 
-      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
-      expect(getCmd?.description()).toBe("Show detailed information about a tool");
+      const infoCmd = program.commands.find((cmd) => cmd.name() === "info");
+      expect(infoCmd?.description()).toBe(
+        "Show detailed information about a tool (local path or registry)"
+      );
     });
 
-    test("has info as alias", () => {
+    test("has get as alias", () => {
       const program = new Command();
-      configureGetCommand(program);
+      configureInfoCommand(program);
 
-      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
-      expect(getCmd?.aliases()).toContain("info");
+      const infoCmd = program.commands.find((cmd) => cmd.name() === "info");
+      expect(infoCmd?.aliases()).toContain("get");
     });
 
     test("accepts tool argument", () => {
       const program = new Command();
-      configureGetCommand(program);
+      configureInfoCommand(program);
 
-      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
-      const args = getCmd?.registeredArguments ?? [];
+      const infoCmd = program.commands.find((cmd) => cmd.name() === "info");
+      const args = infoCmd?.registeredArguments ?? [];
       expect(args.length).toBeGreaterThan(0);
       expect(args[0]?.name()).toBe("tool");
     });
 
     test("has --ver option for specifying version", () => {
       const program = new Command();
-      configureGetCommand(program);
+      configureInfoCommand(program);
 
-      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
-      const opts = getCmd?.options ?? [];
+      const infoCmd = program.commands.find((cmd) => cmd.name() === "info");
+      const opts = infoCmd?.options ?? [];
       const verOpt = opts.find((o) => o.long === "--ver");
       expect(verOpt).toBeDefined();
     });
 
     test("has -v short option for verbose (not version)", () => {
       const program = new Command();
-      configureGetCommand(program);
+      configureInfoCommand(program);
 
-      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
-      const opts = getCmd?.options ?? [];
+      const infoCmd = program.commands.find((cmd) => cmd.name() === "info");
+      const opts = infoCmd?.options ?? [];
       // -v is for verbose, not version (--ver is for version)
       const verboseOpt = opts.find((o) => o.short === "-v");
       expect(verboseOpt).toBeDefined();
@@ -67,20 +69,20 @@ describe("get command", () => {
 
     test("has --json option", () => {
       const program = new Command();
-      configureGetCommand(program);
+      configureInfoCommand(program);
 
-      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
-      const opts = getCmd?.options ?? [];
+      const infoCmd = program.commands.find((cmd) => cmd.name() === "info");
+      const opts = infoCmd?.options ?? [];
       const jsonOpt = opts.find((o) => o.long === "--json");
       expect(jsonOpt).toBeDefined();
     });
 
     test("has --verbose option", () => {
       const program = new Command();
-      configureGetCommand(program);
+      configureInfoCommand(program);
 
-      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
-      const opts = getCmd?.options ?? [];
+      const infoCmd = program.commands.find((cmd) => cmd.name() === "info");
+      const opts = infoCmd?.options ?? [];
       const verboseOpt = opts.find((o) => o.long === "--verbose");
       expect(verboseOpt).toBeDefined();
     });
@@ -249,12 +251,12 @@ Documentation here.`;
       expect(enactMdContent).toContain("Documentation here.");
     });
 
-    test("verbose option is available on get command", () => {
+    test("verbose option is available on info command", () => {
       const program = new Command();
-      configureGetCommand(program);
+      configureInfoCommand(program);
 
-      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
-      const opts = getCmd?.options ?? [];
+      const infoCmd = program.commands.find((cmd) => cmd.name() === "info");
+      const opts = infoCmd?.options ?? [];
 
       // Check both short and long form exist
       const verboseOpt = opts.find((o) => o.long === "--verbose");

package/tests/commands/init.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { Command } from "commander";
 import { configureInitCommand } from "../../src/commands/init";
@@ -107,7 +107,59 @@ describe("init command", () => {
       }
     });
 
-    test("default mode creates enact.md", async () => {
+    test("default mode creates AGENTS.md for tool consumers", async () => {
+      const program = new Command();
+      program.exitOverride();
+      configureInitCommand(program);
+
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await program.parseAsync(["node", "test", "init"]);
+      } catch {
+        // Command may throw due to exitOverride
+      } finally {
+        process.chdir(originalCwd);
+      }
+
+      const agentsPath = join(testDir, "AGENTS.md");
+      expect(existsSync(agentsPath)).toBe(true);
+
+      const content = readFileSync(agentsPath, "utf-8");
+      expect(content).toContain("enact search");
+      expect(content).toContain("enact install");
+      expect(content).toContain("Finding & Installing Tools");
+
+      // Should NOT create enact.md in default mode
+      const manifestPath = join(testDir, "enact.md");
+      expect(existsSync(manifestPath)).toBe(false);
+    });
+
+    test("default mode creates .enact/tools.json", async () => {
+      const program = new Command();
+      program.exitOverride();
+      configureInitCommand(program);
+
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await program.parseAsync(["node", "test", "init"]);
+      } catch {
+        // Command may throw due to exitOverride
+      } finally {
+        process.chdir(originalCwd);
+      }
+
+      const toolsJsonPath = join(testDir, ".enact", "tools.json");
+      expect(existsSync(toolsJsonPath)).toBe(true);
+
+      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
+      expect(content).toEqual({ tools: {} });
+    });
+
+    test("--tool mode creates SKILL.md", async () => {
       const program = new Command();
       program.exitOverride(); // Prevent process.exit
       configureInitCommand(program);
@@ -117,14 +169,14 @@ describe("init command", () => {
       process.chdir(testDir);
 
       try {
-        await program.parseAsync(["node", "test", "init", "--name", "test/my-tool"]);
+        await program.parseAsync(["node", "test", "init", "--tool", "--name", "test/my-tool"]);
       } catch {
         // Command may throw due to exitOverride
       } finally {
         process.chdir(originalCwd);
       }
 
-      const manifestPath = join(testDir, "enact.md");
+      const manifestPath = join(testDir, "SKILL.md");
       expect(existsSync(manifestPath)).toBe(true);
 
       const content = readFileSync(manifestPath, "utf-8");
@@ -133,7 +185,7 @@ describe("init command", () => {
       expect(content).toContain("command:");
     });
 
-    test("default mode creates AGENTS.md for tool development", async () => {
+    test("--tool mode creates AGENTS.md for tool development", async () => {
       const program = new Command();
       program.exitOverride();
       configureInitCommand(program);
@@ -142,7 +194,7 @@ describe("init command", () => {
       process.chdir(testDir);
 
       try {
-        await program.parseAsync(["node", "test", "init", "--name", "test/my-tool"]);
+        await program.parseAsync(["node", "test", "init", "--tool", "--name", "test/my-tool"]);
       } catch {
         // Command may throw due to exitOverride
       } finally {
@@ -154,7 +206,7 @@ describe("init command", () => {
 
       const content = readFileSync(agentsPath, "utf-8");
       expect(content).toContain("enact run");
-      expect(content).toContain("enact.md");
+      expect(content).toContain("SKILL.md");
       expect(content).toContain("Parameter Substitution");
     });
 
@@ -215,7 +267,7 @@ describe("init command", () => {
       expect(existsSync(join(testDir, "AGENTS.md"))).toBe(false);
     });
 
-    test("enact.md contains valid YAML frontmatter", async () => {
+    test("--agent mode creates .enact/tools.json", async () => {
       const program = new Command();
       program.exitOverride();
       configureInitCommand(program);
@@ -224,14 +276,149 @@ describe("init command", () => {
       process.chdir(testDir);
 
       try {
-        await program.parseAsync(["node", "test", "init", "--name", "myorg/utils/greeter"]);
+        await program.parseAsync(["node", "test", "init", "--agent"]);
       } catch {
         // Command may throw due to exitOverride
       } finally {
         process.chdir(originalCwd);
       }
 
-      const content = readFileSync(join(testDir, "enact.md"), "utf-8");
+      const toolsJsonPath = join(testDir, ".enact", "tools.json");
+      expect(existsSync(toolsJsonPath)).toBe(true);
+
+      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
+      expect(content).toEqual({ tools: {} });
+    });
+
+    test("--claude mode creates .enact/tools.json", async () => {
+      const program = new Command();
+      program.exitOverride();
+      configureInitCommand(program);
+
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await program.parseAsync(["node", "test", "init", "--claude"]);
+      } catch {
+        // Command may throw due to exitOverride
+      } finally {
+        process.chdir(originalCwd);
+      }
+
+      const toolsJsonPath = join(testDir, ".enact", "tools.json");
+      expect(existsSync(toolsJsonPath)).toBe(true);
+
+      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
+      expect(content).toEqual({ tools: {} });
+    });
+
+    test("--agent mode with --force overwrites existing .enact/tools.json", async () => {
+      // Create existing .enact/tools.json with some content
+      const enactDir = join(testDir, ".enact");
+      mkdirSync(enactDir, { recursive: true });
+      const toolsJsonPath = join(enactDir, "tools.json");
+      const existingContent = { tools: { "some/tool": "1.0.0" } };
+      writeFileSync(toolsJsonPath, JSON.stringify(existingContent));
+
+      const program = new Command();
+      program.exitOverride();
+      configureInitCommand(program);
+
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await program.parseAsync(["node", "test", "init", "--agent", "--force"]);
+      } catch {
+        // Command may throw due to exitOverride
+      } finally {
+        process.chdir(originalCwd);
+      }
+
+      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
+      expect(content).toEqual({ tools: {} });
+    });
+
+    test("--agent mode preserves existing .enact/tools.json without --force", async () => {
+      // Create existing .enact/tools.json with some content
+      const enactDir = join(testDir, ".enact");
+      mkdirSync(enactDir, { recursive: true });
+      const toolsJsonPath = join(enactDir, "tools.json");
+      const existingContent = { tools: { "some/tool": "1.0.0" } };
+      writeFileSync(toolsJsonPath, JSON.stringify(existingContent));
+
+      // Also create AGENTS.md so the command doesn't fail early
+      writeFileSync(join(testDir, "AGENTS.md"), "existing");
+
+      const program = new Command();
+      program.exitOverride();
+      configureInitCommand(program);
+
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        // Without --force, AGENTS.md check will fail and return early
+        // So we need to test with --force on AGENTS.md but not tools.json
+        // Actually the --force flag applies to both, so let's just verify
+        // tools.json is preserved when it exists and no --force
+        await program.parseAsync(["node", "test", "init", "--agent"]);
+      } catch {
+        // Command may throw due to exitOverride or warning about existing file
+      } finally {
+        process.chdir(originalCwd);
+      }
+
+      // tools.json should be preserved since AGENTS.md existed and no --force was used
+      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
+      expect(content).toEqual(existingContent);
+    });
+
+    test("--tool mode does NOT create .enact/tools.json", async () => {
+      const program = new Command();
+      program.exitOverride();
+      configureInitCommand(program);
+
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await program.parseAsync(["node", "test", "init", "--tool", "--name", "test/my-tool"]);
+      } catch {
+        // Command may throw due to exitOverride
+      } finally {
+        process.chdir(originalCwd);
+      }
+
+      const toolsJsonPath = join(testDir, ".enact", "tools.json");
+      expect(existsSync(toolsJsonPath)).toBe(false);
+    });
+
+    test("SKILL.md contains valid YAML frontmatter", async () => {
+      const program = new Command();
+      program.exitOverride();
+      configureInitCommand(program);
+
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await program.parseAsync([
+          "node",
+          "test",
+          "init",
+          "--tool",
+          "--name",
+          "myorg/utils/greeter",
+        ]);
+      } catch {
+        // Command may throw due to exitOverride
+      } finally {
+        process.chdir(originalCwd);
+      }
+
+      const content = readFileSync(join(testDir, "SKILL.md"), "utf-8");
 
       // Check frontmatter structure
       expect(content.startsWith("---")).toBe(true);
@@ -255,7 +442,7 @@ describe("init command", () => {
       process.chdir(testDir);
 
       try {
-        await program.parseAsync(["node", "test", "init", "--name", "test/tool"]);
+        await program.parseAsync(["node", "test", "init", "--tool", "--name", "test/tool"]);
       } catch {
         // Command may throw due to exitOverride
       } finally {
@@ -299,16 +486,16 @@ describe("init command", () => {
   });
 
   describe("option conflicts", () => {
-    test("--tool is the default when no mode specified", () => {
+    test("--agent is the default when no mode specified", () => {
       const program = new Command();
       configureInitCommand(program);
 
       const initCmd = program.commands.find((cmd) => cmd.name() === "init");
       const opts = initCmd?.options ?? [];
-      const toolOpt = opts.find((o) => o.long === "--tool");
+      const agentOpt = opts.find((o) => o.long === "--agent");
 
       // Description should indicate it's the default
-      expect(toolOpt?.description).toContain("default");
+      expect(agentOpt?.description).toContain("default");
     });
   });
 
@@ -328,14 +515,14 @@ describe("init command", () => {
       process.chdir(testDir);
 
       try {
-        await program.parseAsync(["node", "test", "init", "--name", "test/tool"]);
+        await program.parseAsync(["node", "test", "init", "--tool", "--name", "test/tool"]);
       } catch {
         // Command may throw due to exitOverride
       } finally {
         process.chdir(originalCwd);
       }
 
-      const content = readFileSync(join(testDir, "enact.md"), "utf-8");
+      const content = readFileSync(join(testDir, "SKILL.md"), "utf-8");
 
       // Required fields per spec
       expect(content).toContain("name:");
@@ -367,7 +554,7 @@ describe("init command", () => {
       process.chdir(testDir);
 
       try {
-        await program.parseAsync(["node", "test", "init", "--name", "test/tool"]);
+        await program.parseAsync(["node", "test", "init", "--tool", "--name", "test/tool"]);
       } catch {
         // Command may throw due to exitOverride
       } finally {