@enactprotocol/cli 2.0.4 → 2.0.6

package/tests/commands/get.test.ts

@@ -3,6 +3,7 @@
  */
 
 import { describe, expect, test } from "bun:test";
+import type { ToolVersionInfo } from "@enactprotocol/api";
 import { Command } from "commander";
 import { configureGetCommand } from "../../src/commands/get";
 
@@ -42,24 +43,26 @@ describe("get command", () => {
       expect(args[0]?.name()).toBe("tool");
     });
 
-    test("has --version option", () => {
+    test("has --ver option for specifying version", () => {
       const program = new Command();
       configureGetCommand(program);
 
       const getCmd = program.commands.find((cmd) => cmd.name() === "get");
       const opts = getCmd?.options ?? [];
-      const versionOpt = opts.find((o) => o.long === "--version");
-      expect(versionOpt).toBeDefined();
+      const verOpt = opts.find((o) => o.long === "--ver");
+      expect(verOpt).toBeDefined();
     });
 
-    test("has -v short option for version", () => {
+    test("has -v short option for verbose (not version)", () => {
       const program = new Command();
       configureGetCommand(program);
 
       const getCmd = program.commands.find((cmd) => cmd.name() === "get");
       const opts = getCmd?.options ?? [];
-      const versionOpt = opts.find((o) => o.short === "-v");
-      expect(versionOpt).toBeDefined();
+      // -v is for verbose, not version (--ver is for version)
+      const verboseOpt = opts.find((o) => o.short === "-v");
+      expect(verboseOpt).toBeDefined();
+      expect(verboseOpt?.long).toBe("--verbose");
     });
 
     test("has --json option", () => {
@@ -176,4 +179,87 @@ describe("get command", () => {
       expect(trustLevels).toContain("full");
     });
   });
+
+  describe("verbose mode displays enact.md", () => {
+    test("ToolVersionInfo type includes rawManifest field for enact.md content", () => {
+      // Test that the type includes rawManifest field for enact.md content
+      const mockVersion: ToolVersionInfo = {
+        name: "test/tool",
+        version: "1.0.0",
+        description: "Test tool",
+        license: "MIT",
+        yanked: false,
+        manifest: { enact: "2.0.0" },
+        rawManifest: "---\\nenact: 2.0.0\\n---\\n# Test Tool\\n\\nThis is a test tool.",
+        bundle: {
+          hash: "sha256:abc123",
+          size: 1024,
+          downloadUrl: "https://example.com/bundle.tar.gz",
+        },
+        attestations: [],
+        publishedBy: { username: "testuser" },
+        publishedAt: new Date(),
+        downloads: 100,
+      };
+
+      expect(mockVersion.rawManifest).toBeDefined();
+      expect(mockVersion.rawManifest).toContain("# Test Tool");
+    });
+
+    test("ToolVersionInfo allows undefined rawManifest", () => {
+      const mockVersion: ToolVersionInfo = {
+        name: "test/tool",
+        version: "1.0.0",
+        description: "Test tool",
+        license: "MIT",
+        yanked: false,
+        manifest: { enact: "2.0.0" },
+        // rawManifest is optional - not provided
+        bundle: {
+          hash: "sha256:abc123",
+          size: 1024,
+          downloadUrl: "https://example.com/bundle.tar.gz",
+        },
+        attestations: [],
+        publishedBy: { username: "testuser" },
+        publishedAt: new Date(),
+        downloads: 100,
+      };
+
+      expect(mockVersion.rawManifest).toBeUndefined();
+    });
+
+    test("enact.md content should contain frontmatter and markdown", () => {
+      const enactMdContent = `---
+enact: 2.0.0
+name: test/tool
+version: 1.0.0
+---
+
+# Test Tool
+
+Documentation here.`;
+
+      // Verify frontmatter is present
+      expect(enactMdContent).toContain("---");
+      expect(enactMdContent).toContain("enact: 2.0.0");
+
+      // Verify markdown content
+      expect(enactMdContent).toContain("# Test Tool");
+      expect(enactMdContent).toContain("Documentation here.");
+    });
+
+    test("verbose option is available on get command", () => {
+      const program = new Command();
+      configureGetCommand(program);
+
+      const getCmd = program.commands.find((cmd) => cmd.name() === "get");
+      const opts = getCmd?.options ?? [];
+
+      // Check both short and long form exist
+      const verboseOpt = opts.find((o) => o.long === "--verbose");
+      expect(verboseOpt).toBeDefined();
+      expect(verboseOpt?.short).toBe("-v");
+    });
+  });
 });

package/tests/commands/sign.test.ts

@@ -161,4 +161,63 @@ command: "echo hello"
       expect(predicateType).toContain("tool");
     });
   });
+
+  describe("remote tool reference parsing", () => {
+    test("parses simple remote tool reference with version", () => {
+      const ref = "alice/greeter@1.2.0";
+      const atIndex = ref.lastIndexOf("@");
+      const name = ref.slice(0, atIndex);
+      const version = ref.slice(atIndex + 1);
+
+      expect(name).toBe("alice/greeter");
+      expect(version).toBe("1.2.0");
+    });
+
+    test("parses namespaced tool reference with version", () => {
+      const ref = "org/utils/greeter@2.0.0";
+      const atIndex = ref.lastIndexOf("@");
+      const name = ref.slice(0, atIndex);
+      const version = ref.slice(atIndex + 1);
+
+      expect(name).toBe("org/utils/greeter");
+      expect(version).toBe("2.0.0");
+    });
+
+    test("detects remote vs local tool reference", () => {
+      const isRemoteToolRef = (path: string): boolean => {
+        // Remote refs contain @ for version and don't start with . or /
+        return (
+          !path.startsWith(".") && !path.startsWith("/") && path.includes("@") && path.includes("/")
+        );
+      };
+
+      expect(isRemoteToolRef("alice/greeter@1.0.0")).toBe(true);
+      expect(isRemoteToolRef("./local-tool")).toBe(false);
+      expect(isRemoteToolRef("/absolute/path/tool")).toBe(false);
+      expect(isRemoteToolRef("examples/hello-python")).toBe(false);
+    });
+
+    test("requires version in remote tool reference", () => {
+      const hasVersion = (ref: string): boolean => {
+        return ref.includes("@") && ref.lastIndexOf("@") > 0;
+      };
+
+      expect(hasVersion("alice/greeter@1.0.0")).toBe(true);
+      expect(hasVersion("alice/greeter")).toBe(false);
+    });
+
+    test("validates semver version format", () => {
+      const isValidSemver = (version: string): boolean => {
+        const semverRegex = /^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/;
+        return semverRegex.test(version);
+      };
+
+      expect(isValidSemver("1.0.0")).toBe(true);
+      expect(isValidSemver("2.1.3")).toBe(true);
+      expect(isValidSemver("1.0.0-alpha")).toBe(true);
+      expect(isValidSemver("1.0.0-beta.1")).toBe(true);
+      expect(isValidSemver("invalid")).toBe(false);
+      expect(isValidSemver("1.0")).toBe(false);
+    });
+  });
 });