@enactprotocol/shared 2.2.2 → 2.3.1

package/tests/manifest/loader.test.ts

@@ -34,7 +34,7 @@ describe("manifest loader", () => {
       const filePath = join(FIXTURES_DIR, "valid-tool.yaml");
       const result = loadManifest(filePath);
 
-      expect(result.manifest.name).toBe("acme/utils/greeter");
+      expect(result.manifest.name).toBe("acme/greeter");
       expect(result.manifest.description).toBe("Greets users by name");
       expect(result.manifest.version).toBe("1.0.0");
       expect(result.format).toBe("yaml");
@@ -46,7 +46,7 @@ describe("manifest loader", () => {
       const filePath = join(FIXTURES_DIR, "valid-tool.md");
       const result = loadManifest(filePath);
 
-      expect(result.manifest.name).toBe("acme/docs/analyzer");
+      expect(result.manifest.name).toBe("acme/analyzer");
       expect(result.manifest.description).toBe("Analyzes documentation for completeness");
       expect(result.format).toBe("md");
       expect(result.body).toBeDefined();
@@ -104,11 +104,11 @@ description: A minimal tool
   });
 
   describe("loadManifestFromDir", () => {
-    test("loads manifest from directory with enact.yaml", () => {
+    test("loads manifest from directory with skill.yaml", () => {
       const testDir = join(TEST_DIR, "yaml-dir");
       mkdirSync(testDir, { recursive: true });
       writeFileSync(
-        join(testDir, "enact.yaml"),
+        join(testDir, "skill.yaml"),
         `
 name: test/yaml
 description: Test YAML manifest
@@ -120,6 +120,22 @@ description: Test YAML manifest
       expect(result.manifest.name).toBe("test/yaml");
     });
 
+    test("loads manifest from directory with legacy enact.yaml", () => {
+      const testDir = join(TEST_DIR, "legacy-yaml-dir");
+      mkdirSync(testDir, { recursive: true });
+      writeFileSync(
+        join(testDir, "enact.yaml"),
+        `
+name: test/legacy-yaml
+description: Test legacy YAML manifest
+`,
+        "utf-8"
+      );
+
+      const result = loadManifestFromDir(testDir);
+      expect(result.manifest.name).toBe("test/legacy-yaml");
+    });
+
     test("loads manifest from directory with enact.md", () => {
       const testDir = join(TEST_DIR, "md-dir");
       mkdirSync(testDir, { recursive: true });
@@ -140,31 +156,29 @@ description: Test Markdown manifest
       expect(result.format).toBe("md");
     });
 
-    test("prefers enact.md over enact.yaml", () => {
+    test("prefers skill.yaml over legacy enact.yaml", () => {
       const testDir = join(TEST_DIR, "both-dir");
       mkdirSync(testDir, { recursive: true });
 
-      // Create both files
       writeFileSync(
-        join(testDir, "enact.md"),
-        `---
-name: test/md-preferred
-description: Markdown version
----
+        join(testDir, "skill.yaml"),
+        `
+name: test/skill-preferred
+description: Skill version
 `,
         "utf-8"
       );
       writeFileSync(
         join(testDir, "enact.yaml"),
         `
-name: test/yaml-version
-description: YAML version
+name: test/enact-version
+description: Legacy version
 `,
         "utf-8"
       );
 
       const result = loadManifestFromDir(testDir);
-      expect(result.manifest.name).toBe("test/md-preferred");
+      expect(result.manifest.name).toBe("test/skill-preferred");
     });
 
     test("throws for directory without manifest", () => {
@@ -177,13 +191,13 @@ description: YAML version
   });
 
   describe("findManifestFile", () => {
-    test("finds enact.yaml", () => {
+    test("finds skill.yaml", () => {
       const testDir = join(TEST_DIR, "find-yaml");
       mkdirSync(testDir, { recursive: true });
-      writeFileSync(join(testDir, "enact.yaml"), "name: test/find", "utf-8");
+      writeFileSync(join(testDir, "skill.yaml"), "name: test/find", "utf-8");
 
       const result = findManifestFile(testDir);
-      expect(result).toBe(join(testDir, "enact.yaml"));
+      expect(result).toBe(join(testDir, "skill.yaml"));
     });
 
     test("finds enact.md", () => {
@@ -208,7 +222,7 @@ description: YAML version
     test("returns true when manifest exists", () => {
       const testDir = join(TEST_DIR, "has-manifest");
       mkdirSync(testDir, { recursive: true });
-      writeFileSync(join(testDir, "enact.yaml"), "name: test/has", "utf-8");
+      writeFileSync(join(testDir, "skill.yaml"), "name: test/has", "utf-8");
 
       expect(hasManifest(testDir)).toBe(true);
     });
@@ -227,7 +241,7 @@ description: YAML version
       const result = tryLoadManifest(filePath);
 
       expect(result).not.toBeNull();
-      expect(result?.manifest.name).toBe("acme/utils/greeter");
+      expect(result?.manifest.name).toBe("acme/greeter");
     });
 
     test("returns null on failure", () => {
@@ -250,7 +264,7 @@ description: YAML version
       const testDir = join(TEST_DIR, "try-success");
       mkdirSync(testDir, { recursive: true });
       writeFileSync(
-        join(testDir, "enact.yaml"),
+        join(testDir, "skill.yaml"),
         `
 name: test/try
 description: Test try loading

package/tests/manifest/parser.test.ts

@@ -25,15 +25,15 @@ version: "1.0.0"
     test("parses nested YAML", () => {
       const yaml = `
 name: org/tool
-inputSchema:
+outputSchema:
   type: object
   properties:
     name:
       type: string
 `;
       const result = parseYaml(yaml);
-      expect(result.inputSchema).toBeDefined();
-      const schema = result.inputSchema as Record<string, unknown>;
+      expect(result.outputSchema).toBeDefined();
+      const schema = result.outputSchema as Record<string, unknown>;
       expect(schema.type).toBe("object");
     });
 
@@ -169,27 +169,21 @@ description: A test tool
       test("parses complete YAML manifest", () => {
         const yaml = `
 enact: "2.0.0"
-name: acme/utils/greeter
+name: acme/greeter
 description: Greets users
 version: "1.0.0"
 from: node:18-alpine
-command: "echo 'Hello \${name}'"
 timeout: 30s
 license: MIT
 tags:
   - greeting
   - utility
-inputSchema:
-  type: object
-  properties:
-    name:
-      type: string
-  required:
-    - name
+scripts:
+  greet: "echo 'Hello {{name}}'"
 `;
         const result = parseManifest(yaml, "yaml");
         expect(result.manifest.enact).toBe("2.0.0");
-        expect(result.manifest.name).toBe("acme/utils/greeter");
+        expect(result.manifest.name).toBe("acme/greeter");
         expect(result.manifest.from).toBe("node:18-alpine");
         expect(result.manifest.tags).toContain("greeting");
       });
@@ -266,12 +260,14 @@ Body here.
 
   describe("detectFormat", () => {
     test("detects .yaml extension", () => {
+      expect(detectFormat("skill.yaml")).toBe("yaml");
       expect(detectFormat("enact.yaml")).toBe("yaml");
       expect(detectFormat("tool.yaml")).toBe("yaml");
-      expect(detectFormat("/path/to/enact.yaml")).toBe("yaml");
+      expect(detectFormat("/path/to/skill.yaml")).toBe("yaml");
     });
 
     test("detects .yml extension", () => {
+      expect(detectFormat("skill.yml")).toBe("yaml");
       expect(detectFormat("enact.yml")).toBe("yaml");
       expect(detectFormat("/path/to/tool.yml")).toBe("yaml");
     });
@@ -302,7 +298,7 @@ Body here.
 name: org/tool
 description: Test
 `;
-      const result = parseManifestAuto(yaml, "enact.yaml");
+      const result = parseManifestAuto(yaml, "skill.yaml");
       expect(result.manifest.name).toBe("org/tool");
       expect(result.format).toBe("yaml");
     });

package/tests/manifest/validator.test.ts

@@ -24,7 +24,7 @@ describe("manifest validator", () => {
     test("validates complete manifest", () => {
       const manifest = {
         enact: "2.0.0",
-        name: "acme/utils/greeter",
+        name: "acme/greeter",
         description: "Greets users by name",
         version: "1.0.0",
         from: "node:18-alpine",
@@ -32,12 +32,8 @@ describe("manifest validator", () => {
         timeout: "30s",
         license: "MIT",
         tags: ["greeting", "utility"],
-        inputSchema: {
-          type: "object",
-          properties: {
-            name: { type: "string" },
-          },
-          required: ["name"],
+        scripts: {
+          greet: "echo 'Hello {{name}}'",
         },
         outputSchema: {
           type: "object",
@@ -222,13 +218,7 @@ describe("manifest validator", () => {
     });
 
     test("accepts valid tool name formats", () => {
-      const names = [
-        "org/tool",
-        "acme/utils/greeter",
-        "my-org/category/sub-category/tool-name",
-        "a/b",
-        "org_name/tool_name",
-      ];
+      const names = ["org/tool", "acme/greeter", "@my-org/tool-name", "a/b", "org_name/tool_name"];
 
       for (const name of names) {
         const manifest = { name, description: "Test" };
@@ -405,7 +395,7 @@ describe("manifest validator", () => {
     describe("isValidToolName", () => {
       test("returns true for valid names", () => {
         expect(isValidToolName("org/tool")).toBe(true);
-        expect(isValidToolName("acme/utils/greeter")).toBe(true);
+        expect(isValidToolName("@acme/greeter")).toBe(true);
         expect(isValidToolName("my-org/my-tool")).toBe(true);
         expect(isValidToolName("org_name/tool_name")).toBe(true);
       });
@@ -425,9 +415,9 @@ describe("manifest validator", () => {
         expect(isValidLocalToolName("simple")).toBe(true);
       });
 
-      test("returns true for hierarchical names", () => {
+      test("returns true for scoped names", () => {
         expect(isValidLocalToolName("org/tool")).toBe(true);
-        expect(isValidLocalToolName("acme/utils/greeter")).toBe(true);
+        expect(isValidLocalToolName("@acme/greeter")).toBe(true);
       });
 
       test("returns false for invalid names", () => {

package/tests/manifest-types.test.ts

@@ -29,7 +29,7 @@ describe("manifest types", () => {
 
     test("accepts full manifest with all fields", () => {
       const manifest: ToolManifest = {
-        name: "acme/utils/greeter",
+        name: "acme/greeter",
         description: "Greets users by name",
         enact: "2.0.0",
         version: "1.0.0",
@@ -38,12 +38,8 @@ describe("manifest types", () => {
         timeout: "30s",
         license: "MIT",
         tags: ["greeting", "utility"],
-        inputSchema: {
-          type: "object",
-          properties: {
-            name: { type: "string" },
-          },
-          required: ["name"],
+        scripts: {
+          greet: "echo 'Hello {{name}}'",
         },
         outputSchema: {
           type: "object",
@@ -90,7 +86,7 @@ describe("manifest types", () => {
         "x-custom-field": "custom value",
       };
 
-      expect(manifest.name).toBe("acme/utils/greeter");
+      expect(manifest.name).toBe("acme/greeter");
       expect(manifest.enact).toBe("2.0.0");
       expect(manifest.env?.API_KEY?.secret).toBe(true);
       expect(manifest.annotations?.readOnlyHint).toBe(true);
@@ -314,7 +310,7 @@ describe("manifest types", () => {
         },
         sourceDir: "/home/user/.enact/tools/org/tool",
         location: "user",
-        manifestPath: "/home/user/.enact/tools/org/tool/enact.yaml",
+        manifestPath: "/home/user/.enact/tools/org/tool/skill.yaml",
         version: "1.0.0",
       };
 
@@ -336,7 +332,7 @@ describe("manifest types", () => {
           manifest: { name: "test", description: "test" },
           sourceDir: "/test",
           location: loc,
-          manifestPath: "/test/enact.yaml",
+          manifestPath: "/test/skill.yaml",
         };
         expect(resolution.location).toBe(loc);
       }
@@ -346,10 +342,12 @@ describe("manifest types", () => {
   describe("constants", () => {
     test("MANIFEST_FILES contains expected files", () => {
       expect(MANIFEST_FILES).toContain("SKILL.md");
+      expect(MANIFEST_FILES).toContain("skill.yaml");
+      expect(MANIFEST_FILES).toContain("skill.yml");
       expect(MANIFEST_FILES).toContain("enact.md");
       expect(MANIFEST_FILES).toContain("enact.yaml");
       expect(MANIFEST_FILES).toContain("enact.yml");
-      expect(MANIFEST_FILES.length).toBe(4);
+      expect(MANIFEST_FILES.length).toBe(6);
     });
 
     test("PACKAGE_MANIFEST_FILE is correct", () => {

package/tests/paths.test.ts

@@ -9,6 +9,7 @@ import {
   getGlobalEnvPath,
   getProjectEnactDir,
   getProjectEnvPath,
+  getSkillsDir,
   getToolsDir,
 } from "../src/paths";
 
@@ -106,14 +107,20 @@ describe("path utilities", () => {
     });
   });
 
-  describe("getCacheDir", () => {
-    test("returns ~/.enact/cache/ path", () => {
-      const result = getCacheDir();
-      const expected = join(homedir(), ".enact", "cache");
+  describe("getSkillsDir", () => {
+    test("returns ~/.agent/skills/ path", () => {
+      const result = getSkillsDir();
+      const expected = join(homedir(), ".agent", "skills");
       expect(result).toBe(expected);
     });
   });
 
+  describe("getCacheDir (deprecated)", () => {
+    test("returns same path as getSkillsDir", () => {
+      expect(getCacheDir()).toBe(getSkillsDir());
+    });
+  });
+
   describe("getConfigPath", () => {
     test("returns ~/.enact/config.yaml path", () => {
       const result = getConfigPath();

package/tests/registry.test.ts

@@ -6,14 +6,19 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import {
+  addAlias,
   addToolToRegistry,
+  getAliasesForTool,
   getInstalledVersion,
   getToolCachePath,
   getToolsJsonPath,
   isToolInstalled,
   listInstalledTools,
   loadToolsRegistry,
+  removeAlias,
+  removeAliasesForTool,
   removeToolFromRegistry,
+  resolveAlias,
   saveToolsRegistry,
 } from "../src/registry";
 
@@ -194,18 +199,19 @@ describe("registry", () => {
   });
 
   describe("getToolCachePath", () => {
-    test("returns cache path with version", () => {
+    test("returns skill path under ~/.agent/skills/", () => {
       const path = getToolCachePath("org/tool", "1.0.0");
-      expect(path).toContain(".enact");
-      expect(path).toContain("cache");
+      expect(path).toContain(".agent");
+      expect(path).toContain("skills");
       expect(path).toContain("org/tool");
-      expect(path).toContain("v1.0.0");
+      // No version subdirectory in new layout
+      expect(path).not.toContain("v1.0.0");
     });
 
-    test("normalizes version prefix", () => {
-      const pathWithV = getToolCachePath("org/tool", "v1.0.0");
-      const pathWithoutV = getToolCachePath("org/tool", "1.0.0");
-      expect(pathWithV).toBe(pathWithoutV);
+    test("returns same path regardless of version", () => {
+      const path1 = getToolCachePath("org/tool", "1.0.0");
+      const path2 = getToolCachePath("org/tool", "2.0.0");
+      expect(path1).toBe(path2);
     });
   });
 
@@ -228,4 +234,194 @@ describe("registry", () => {
       expect(tools.length).toBe(0);
     });
   });
+
+  describe("addAlias", () => {
+    test("adds alias to registry", () => {
+      addToolToRegistry("test/aliased-tool", "1.0.0", "project", PROJECT_DIR);
+      addAlias("mytool", "test/aliased-tool", "project", PROJECT_DIR);
+
+      const registry = loadToolsRegistry("project", PROJECT_DIR);
+      expect(registry.aliases?.mytool).toBe("test/aliased-tool");
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+
+    test("throws error when alias already exists for different tool", () => {
+      addToolToRegistry("test/tool1", "1.0.0", "project", PROJECT_DIR);
+      addToolToRegistry("test/tool2", "1.0.0", "project", PROJECT_DIR);
+      addAlias("shared", "test/tool1", "project", PROJECT_DIR);
+
+      expect(() => {
+        addAlias("shared", "test/tool2", "project", PROJECT_DIR);
+      }).toThrow('Alias "shared" already exists for tool "test/tool1"');
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+
+    test("allows adding same alias for same tool (idempotent)", () => {
+      addToolToRegistry("test/same-tool", "1.0.0", "project", PROJECT_DIR);
+      addAlias("same", "test/same-tool", "project", PROJECT_DIR);
+
+      // Should not throw
+      expect(() => {
+        addAlias("same", "test/same-tool", "project", PROJECT_DIR);
+      }).not.toThrow();
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+  });
+
+  describe("removeAlias", () => {
+    test("removes existing alias", () => {
+      addToolToRegistry("test/removable", "1.0.0", "project", PROJECT_DIR);
+      addAlias("removeme", "test/removable", "project", PROJECT_DIR);
+
+      const removed = removeAlias("removeme", "project", PROJECT_DIR);
+      expect(removed).toBe(true);
+
+      const registry = loadToolsRegistry("project", PROJECT_DIR);
+      expect(registry.aliases?.removeme).toBeUndefined();
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+
+    test("returns false for non-existent alias", () => {
+      const removed = removeAlias("nonexistent", "project", PROJECT_DIR);
+      expect(removed).toBe(false);
+    });
+  });
+
+  describe("resolveAlias", () => {
+    test("resolves existing alias to tool name", () => {
+      addToolToRegistry("org/full-name", "1.0.0", "project", PROJECT_DIR);
+      addAlias("short", "org/full-name", "project", PROJECT_DIR);
+
+      const resolved = resolveAlias("short", "project", PROJECT_DIR);
+      expect(resolved).toBe("org/full-name");
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+
+    test("returns null for non-existent alias", () => {
+      const resolved = resolveAlias("unknown", "project", PROJECT_DIR);
+      expect(resolved).toBeNull();
+    });
+  });
+
+  describe("getAliasesForTool", () => {
+    test("returns all aliases for a tool", () => {
+      addToolToRegistry("test/multi-alias", "1.0.0", "project", PROJECT_DIR);
+      addAlias("alias1", "test/multi-alias", "project", PROJECT_DIR);
+      addAlias("alias2", "test/multi-alias", "project", PROJECT_DIR);
+
+      const aliases = getAliasesForTool("test/multi-alias", "project", PROJECT_DIR);
+      expect(aliases).toContain("alias1");
+      expect(aliases).toContain("alias2");
+      expect(aliases.length).toBe(2);
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+
+    test("returns empty array for tool without aliases", () => {
+      addToolToRegistry("test/no-alias", "1.0.0", "project", PROJECT_DIR);
+
+      const aliases = getAliasesForTool("test/no-alias", "project", PROJECT_DIR);
+      expect(aliases).toEqual([]);
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+  });
+
+  describe("removeAliasesForTool", () => {
+    test("removes all aliases for a tool", () => {
+      addToolToRegistry("test/cleanup", "1.0.0", "project", PROJECT_DIR);
+      addAlias("cleanup1", "test/cleanup", "project", PROJECT_DIR);
+      addAlias("cleanup2", "test/cleanup", "project", PROJECT_DIR);
+
+      const removed = removeAliasesForTool("test/cleanup", "project", PROJECT_DIR);
+      expect(removed).toBe(2);
+
+      const registry = loadToolsRegistry("project", PROJECT_DIR);
+      expect(registry.aliases?.cleanup1).toBeUndefined();
+      expect(registry.aliases?.cleanup2).toBeUndefined();
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+
+    test("returns 0 for tool without aliases", () => {
+      addToolToRegistry("test/no-aliases-to-remove", "1.0.0", "project", PROJECT_DIR);
+
+      const removed = removeAliasesForTool("test/no-aliases-to-remove", "project", PROJECT_DIR);
+      expect(removed).toBe(0);
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+
+    test("does not remove aliases for other tools", () => {
+      addToolToRegistry("test/keep", "1.0.0", "project", PROJECT_DIR);
+      addToolToRegistry("test/remove", "1.0.0", "project", PROJECT_DIR);
+      addAlias("keepme", "test/keep", "project", PROJECT_DIR);
+      addAlias("removeme", "test/remove", "project", PROJECT_DIR);
+
+      removeAliasesForTool("test/remove", "project", PROJECT_DIR);
+
+      const registry = loadToolsRegistry("project", PROJECT_DIR);
+      expect(registry.aliases?.keepme).toBe("test/keep");
+      expect(registry.aliases?.removeme).toBeUndefined();
+
+      // Clean up
+      rmSync(join(PROJECT_ENACT_DIR, "tools.json"));
+    });
+  });
+
+  describe("loadToolsRegistry with aliases", () => {
+    test("loads existing registry with aliases", () => {
+      const registryPath = join(PROJECT_ENACT_DIR, "tools.json");
+      writeFileSync(
+        registryPath,
+        JSON.stringify({
+          tools: {
+            "test/tool": "1.0.0",
+          },
+          aliases: {
+            t: "test/tool",
+          },
+        })
+      );
+
+      const registry = loadToolsRegistry("project", PROJECT_DIR);
+      expect(registry.tools["test/tool"]).toBe("1.0.0");
+      expect(registry.aliases?.t).toBe("test/tool");
+
+      // Clean up
+      rmSync(registryPath);
+    });
+
+    test("returns empty aliases when not present in file", () => {
+      const registryPath = join(PROJECT_ENACT_DIR, "tools.json");
+      writeFileSync(
+        registryPath,
+        JSON.stringify({
+          tools: {
+            "test/tool": "1.0.0",
+          },
+        })
+      );
+
+      const registry = loadToolsRegistry("project", PROJECT_DIR);
+      expect(registry.aliases).toEqual({});
+
+      // Clean up
+      rmSync(registryPath);
+    });
+  });
 });