@enactprotocol/shared 2.2.4 → 2.3.4

package/tests/effective-input-schema.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Tests for getEffectiveInputSchema and DEFAULT_INPUT_SCHEMA.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { DEFAULT_INPUT_SCHEMA, getEffectiveInputSchema } from "../src/types/actions";
+import type { Action } from "../src/types/actions";
+
+describe("DEFAULT_INPUT_SCHEMA", () => {
+  test("is an object type schema", () => {
+    expect(DEFAULT_INPUT_SCHEMA.type).toBe("object");
+  });
+
+  test("has empty properties", () => {
+    expect(DEFAULT_INPUT_SCHEMA.properties).toEqual({});
+  });
+
+  test("has no required fields", () => {
+    expect(DEFAULT_INPUT_SCHEMA.required).toBeUndefined();
+  });
+});
+
+describe("getEffectiveInputSchema", () => {
+  test("returns action inputSchema when provided", () => {
+    const action: Action = {
+      description: "test",
+      command: ["echo"],
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string" } },
+        required: ["name"],
+      },
+    };
+
+    const schema = getEffectiveInputSchema(action);
+    expect(schema).toBe(action.inputSchema!);
+    expect(schema.required).toEqual(["name"]);
+  });
+
+  test("returns DEFAULT_INPUT_SCHEMA when no inputSchema", () => {
+    const action: Action = {
+      description: "test",
+      command: "echo hello",
+    };
+
+    const schema = getEffectiveInputSchema(action);
+    expect(schema).toBe(DEFAULT_INPUT_SCHEMA);
+    expect(schema.type).toBe("object");
+    expect(schema.properties).toEqual({});
+  });
+
+  test("returns DEFAULT_INPUT_SCHEMA when inputSchema is undefined", () => {
+    const action = {
+      description: "test",
+      command: ["echo", "hello"],
+    } as Action;
+
+    const schema = getEffectiveInputSchema(action);
+    expect(schema).toBe(DEFAULT_INPUT_SCHEMA);
+  });
+
+  test("preserves complex inputSchema with nested properties", () => {
+    const action: Action = {
+      description: "test",
+      command: ["cmd"],
+      inputSchema: {
+        type: "object",
+        properties: {
+          config: {
+            type: "object",
+            properties: {
+              depth: { type: "number", default: 3 },
+              format: { type: "string", enum: ["json", "csv"] },
+            },
+          },
+        },
+        required: ["config"],
+      },
+    };
+
+    const schema = getEffectiveInputSchema(action);
+    expect(schema.required).toEqual(["config"]);
+    const props = schema.properties as Record<string, { type: string }>;
+    expect(props.config!.type).toBe("object");
+  });
+});

package/tests/fixtures/valid-tool.md

@@ -1,23 +1,16 @@
 ---
 enact: "2.0.0"
-name: acme/docs/analyzer
+name: acme/analyzer
 description: Analyzes documentation for completeness
 version: "1.2.0"
 from: python:3.11-slim
-command: "python analyze.py ${file}"
 timeout: 5m
 license: Apache-2.0
 tags:
   - documentation
   - analysis
-inputSchema:
-  type: object
-  properties:
-    file:
-      type: string
-      description: Path to the documentation file
-  required:
-    - file
+scripts:
+  analyze: "python analyze.py {{file}}"
 outputSchema:
   type: object
   properties:
@@ -39,7 +32,7 @@ Provide a path to a documentation file and get a quality score along with
 any issues found.
 
 ```bash
-enact run acme/docs/analyzer --file README.md
+enact run acme/analyzer --file README.md
 ```
 
 ## Output
@@ -54,7 +47,7 @@ The tool returns a JSON object with:
 ### Basic Analysis
 
 ```bash
-enact run acme/docs/analyzer --file docs/api.md
+enact run acme/analyzer --file docs/api.md
 ```
 
 ### Integration with CI

package/tests/fixtures/valid-tool.yaml

@@ -1,22 +1,15 @@
 enact: "2.0.0"
-name: acme/utils/greeter
+name: acme/greeter
 description: Greets users by name
 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
-      description: The name to greet
-  required:
-    - name
+scripts:
+  greet: "echo 'Hello {{name}}!'"
 outputSchema:
   type: object
   properties:

package/tests/hooks.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Tests for the ToolHooks type and postinstall hook behavior.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import type { ToolHooks, ToolManifest } from "../src/types/manifest";
+
+const FIXTURES_DIR = join(import.meta.dir, "fixtures", "hooks-test");
+
+beforeAll(() => {
+  mkdirSync(FIXTURES_DIR, { recursive: true });
+});
+
+afterAll(() => {
+  if (existsSync(FIXTURES_DIR)) {
+    rmSync(FIXTURES_DIR, { recursive: true, force: true });
+  }
+});
+
+describe("ToolHooks type", () => {
+  test("manifest accepts hooks with postinstall string", () => {
+    const manifest: ToolManifest = {
+      name: "@test/with-hook",
+      description: "A tool with a postinstall hook",
+      hooks: {
+        postinstall: "npm install",
+      },
+    };
+    expect(manifest.hooks?.postinstall).toBe("npm install");
+  });
+
+  test("manifest accepts hooks with postinstall array", () => {
+    const manifest: ToolManifest = {
+      name: "@test/with-hooks",
+      description: "A tool with multiple postinstall commands",
+      hooks: {
+        postinstall: ["npm install", "npm run build"],
+      },
+    };
+    expect(manifest.hooks?.postinstall).toEqual(["npm install", "npm run build"]);
+  });
+
+  test("manifest works without hooks", () => {
+    const manifest: ToolManifest = {
+      name: "@test/no-hooks",
+      description: "A tool without hooks",
+    };
+    expect(manifest.hooks).toBeUndefined();
+  });
+
+  test("hooks field can be empty object", () => {
+    const hooks: ToolHooks = {};
+    expect(hooks.postinstall).toBeUndefined();
+  });
+});
+
+describe("postinstall hook execution", () => {
+  test("single command creates expected side-effect", async () => {
+    const toolDir = join(FIXTURES_DIR, "single-cmd");
+    mkdirSync(toolDir, { recursive: true });
+
+    const markerFile = join(toolDir, "postinstall-ran.txt");
+    const cmd = `echo "hook executed" > postinstall-ran.txt`;
+
+    const proc = Bun.spawn(["sh", "-c", cmd], {
+      cwd: toolDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await proc.exited;
+
+    expect(existsSync(markerFile)).toBe(true);
+    const content = await Bun.file(markerFile).text();
+    expect(content.trim()).toBe("hook executed");
+  });
+
+  test("multiple commands run sequentially", async () => {
+    const toolDir = join(FIXTURES_DIR, "multi-cmd");
+    mkdirSync(toolDir, { recursive: true });
+
+    const commands = [
+      'echo "step1" > step1.txt',
+      'echo "step2" > step2.txt',
+      "cat step1.txt step2.txt > combined.txt",
+    ];
+
+    for (const cmd of commands) {
+      const proc = Bun.spawn(["sh", "-c", cmd], {
+        cwd: toolDir,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const exitCode = await proc.exited;
+      expect(exitCode).toBe(0);
+    }
+
+    const combined = await Bun.file(join(toolDir, "combined.txt")).text();
+    expect(combined).toContain("step1");
+    expect(combined).toContain("step2");
+  });
+
+  test("failing command returns non-zero exit code", async () => {
+    const toolDir = join(FIXTURES_DIR, "fail-cmd");
+    mkdirSync(toolDir, { recursive: true });
+
+    const proc = Bun.spawn(["sh", "-c", "exit 1"], {
+      cwd: toolDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const exitCode = await proc.exited;
+
+    expect(exitCode).toBe(1);
+  });
+
+  test("command runs in the tool directory (cwd)", async () => {
+    const toolDir = join(FIXTURES_DIR, "cwd-check");
+    mkdirSync(toolDir, { recursive: true });
+
+    const proc = Bun.spawn(["sh", "-c", "pwd"], {
+      cwd: toolDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await proc.exited;
+
+    const output = await new Response(proc.stdout).text();
+    expect(output.trim()).toBe(toolDir);
+  });
+
+  test("command inherits environment variables", async () => {
+    const toolDir = join(FIXTURES_DIR, "env-check");
+    mkdirSync(toolDir, { recursive: true });
+
+    const proc = Bun.spawn(["sh", "-c", "echo $HOME"], {
+      cwd: toolDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env },
+    });
+    await proc.exited;
+
+    const output = await new Response(proc.stdout).text();
+    expect(output.trim()).toBeTruthy();
+    expect(output.trim()).toBe(process.env.HOME!);
+  });
+});
+
+describe("manifest with hooks serialization", () => {
+  test("hooks survive JSON round-trip (single command)", () => {
+    const manifest: ToolManifest = {
+      name: "@test/roundtrip",
+      description: "test",
+      hooks: { postinstall: "make build" },
+    };
+
+    const json = JSON.stringify(manifest);
+    const parsed = JSON.parse(json) as ToolManifest;
+
+    expect(parsed.hooks?.postinstall).toBe("make build");
+  });
+
+  test("hooks survive JSON round-trip (command array)", () => {
+    const manifest: ToolManifest = {
+      name: "@test/roundtrip-array",
+      description: "test",
+      hooks: { postinstall: ["npm ci", "npm run build"] },
+    };
+
+    const json = JSON.stringify(manifest);
+    const parsed = JSON.parse(json) as ToolManifest;
+
+    expect(parsed.hooks?.postinstall).toEqual(["npm ci", "npm run build"]);
+  });
+});

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", () => {