@tbsten/mir-core 0.0.1-alpha02

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@tbsten/mir-core",
+  "version": "0.0.1-alpha02",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "handlebars": "^4.7.8",
+    "js-yaml": "^4.1.1"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "typescript": "^5",
+    "vitest": "^3"
+  }
+}

package/src/__tests__/errors.test.ts

@@ -0,0 +1,71 @@
+/**
+ * mir-core: エラークラスの unit テスト
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  MirError,
+  ValidationError,
+  SnippetNotFoundError,
+  SnippetAlreadyExistsError,
+  RegistryNotFoundError,
+  RegistryRemoteError,
+  PathTraversalError,
+  FileConflictError,
+  setLocale,
+} from "../index.js";
+
+// TODO: 現時点では理想の挙動をテストケースとして記述。後で有効化する。
+
+describe("エラークラス", () => {
+  beforeEach(() => {
+    setLocale("ja");
+  });
+
+  it("MirError は Error を継承", () => {
+    const err = new MirError("test");
+    expect(err).toBeInstanceOf(Error);
+    expect(err.name).toBe("MirError");
+  });
+
+  it("ValidationError は MirError を継承", () => {
+    const err = new ValidationError("test");
+    expect(err).toBeInstanceOf(MirError);
+    expect(err.name).toBe("ValidationError");
+  });
+
+  it("SnippetNotFoundError のメッセージに名前が含まれる", () => {
+    const err = new SnippetNotFoundError("react-hook");
+    expect(err.message).toContain("react-hook");
+    expect(err.name).toBe("SnippetNotFoundError");
+  });
+
+  it("SnippetAlreadyExistsError のメッセージに名前が含まれる", () => {
+    const err = new SnippetAlreadyExistsError("react-hook");
+    expect(err.message).toContain("react-hook");
+  });
+
+  it("RegistryNotFoundError のメッセージに名前が含まれる", () => {
+    const err = new RegistryNotFoundError("my-registry");
+    expect(err.message).toContain("my-registry");
+  });
+
+  it("RegistryRemoteError (名前あり)", () => {
+    const err = new RegistryRemoteError("remote-reg");
+    expect(err.message).toContain("remote-reg");
+  });
+
+  it("RegistryRemoteError (名前なし)", () => {
+    const err = new RegistryRemoteError();
+    expect(err.message).not.toBe("");
+  });
+
+  it("PathTraversalError のメッセージにパスが含まれる", () => {
+    const err = new PathTraversalError("../etc/passwd");
+    expect(err.message).toContain("../etc/passwd");
+  });
+
+  it("FileConflictError のメッセージにパスが含まれる", () => {
+    const err = new FileConflictError("index.ts");
+    expect(err.message).toContain("index.ts");
+  });
+});

package/src/__tests__/hooks.test.ts

@@ -0,0 +1,145 @@
+/**
+ * mir-core: hooks エンジンの unit テスト
+ */
+import { describe, it, expect, vi } from "vitest";
+import { executeHooks, ExitHookError, MirError } from "../index.js";
+import type { Action } from "../index.js";
+
+// TODO: 現時点では理想の挙動をテストケースとして記述。後で有効化する。
+
+describe("executeHooks", () => {
+  describe("echo アクション", () => {
+    it("onEcho コールバックが呼ばれる", () => {
+      const onEcho = vi.fn();
+      const actions: Action[] = [{ echo: "hello" }];
+      executeHooks(actions, {}, { onEcho });
+      expect(onEcho).toHaveBeenCalledWith("hello");
+    });
+
+    it("echo メッセージ内の変数が展開される", () => {
+      const onEcho = vi.fn();
+      const actions: Action[] = [{ echo: "Hello, {{ name }}!" }];
+      executeHooks(actions, { name: "World" }, { onEcho });
+      expect(onEcho).toHaveBeenCalledWith("Hello, World!");
+    });
+
+    it("onEcho が未設定でもエラーにならない", () => {
+      const actions: Action[] = [{ echo: "hello" }];
+      expect(() => executeHooks(actions, {})).not.toThrow();
+    });
+  });
+
+  describe("exit アクション", () => {
+    it("exit: true で ExitHookError を throw", () => {
+      const actions: Action[] = [{ exit: true }];
+      expect(() => executeHooks(actions, {})).toThrow(ExitHookError);
+    });
+
+    it("exit: false では throw しない", () => {
+      const actions: Action[] = [{ exit: false }];
+      expect(() => executeHooks(actions, {})).not.toThrow();
+    });
+
+    it("if 条件が truthy の場合に exit", () => {
+      const actions: Action[] = [{ exit: true, if: "{{ flag }}" }];
+      expect(() => executeHooks(actions, { flag: "yes" })).toThrow(
+        ExitHookError,
+      );
+    });
+
+    it("if 条件が falsy (空文字) の場合は exit しない", () => {
+      const actions: Action[] = [{ exit: true, if: "{{ flag }}" }];
+      expect(() => executeHooks(actions, { flag: "" })).not.toThrow();
+    });
+
+    it("if 条件が 'false' の場合は exit しない", () => {
+      const actions: Action[] = [{ exit: true, if: "{{ flag }}" }];
+      expect(() => executeHooks(actions, { flag: "false" })).not.toThrow();
+    });
+
+    it("if 条件が '0' の場合は exit しない", () => {
+      const actions: Action[] = [{ exit: true, if: "{{ flag }}" }];
+      expect(() => executeHooks(actions, { flag: "0" })).not.toThrow();
+    });
+  });
+
+  describe("input アクション", () => {
+    it("default 値がある場合は変数に設定される", () => {
+      const actions: Action[] = [
+        {
+          input: {
+            q: {
+              "answer-to": "answer",
+              schema: { default: "yes" },
+            },
+          },
+        },
+      ];
+      const result = executeHooks(actions, {});
+      expect(result.answer).toBe("yes");
+    });
+
+    it("default がなく answer-to がある場合はエラー", () => {
+      const actions: Action[] = [
+        {
+          input: {
+            q: { "answer-to": "answer" },
+          },
+        },
+      ];
+      expect(() => executeHooks(actions, {})).toThrow(MirError);
+    });
+
+    it("answer-to がない場合はスキップ", () => {
+      const actions: Action[] = [
+        {
+          input: { q: { description: "test" } },
+        },
+      ];
+      expect(() => executeHooks(actions, {})).not.toThrow();
+    });
+  });
+
+  describe("複合アクション", () => {
+    it("複数のアクションが順番に実行される", () => {
+      const onEcho = vi.fn();
+      const actions: Action[] = [
+        { echo: "step1" },
+        { echo: "step2" },
+        { echo: "step3" },
+      ];
+      executeHooks(actions, {}, { onEcho });
+      expect(onEcho).toHaveBeenCalledTimes(3);
+      expect(onEcho.mock.calls[0][0]).toBe("step1");
+      expect(onEcho.mock.calls[1][0]).toBe("step2");
+      expect(onEcho.mock.calls[2][0]).toBe("step3");
+    });
+
+    it("exit が途中で発生すると後続アクションは実行されない", () => {
+      const onEcho = vi.fn();
+      const actions: Action[] = [
+        { echo: "before" },
+        { exit: true },
+        { echo: "after" },
+      ];
+      expect(() => executeHooks(actions, {}, { onEcho })).toThrow(
+        ExitHookError,
+      );
+      expect(onEcho).toHaveBeenCalledTimes(1);
+      expect(onEcho).toHaveBeenCalledWith("before");
+    });
+
+    it("元の変数オブジェクトは変更されない (immutable)", () => {
+      const original = { key: "original" };
+      const actions: Action[] = [
+        {
+          input: {
+            q: { "answer-to": "newKey", schema: { default: "value" } },
+          },
+        },
+      ];
+      executeHooks(actions, original);
+      expect(original).not.toHaveProperty("newKey");
+    });
+  });
+});

package/src/__tests__/i18n.test.ts

@@ -0,0 +1,60 @@
+/**
+ * mir-core: i18n の unit テスト
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { setLocale, getLocale, t } from "../index.js";
+import type { Locale } from "../index.js";
+
+// TODO: 現時点では理想の挙動をテストケースとして記述。後で有効化する。
+
+describe("i18n", () => {
+  beforeEach(() => {
+    setLocale("ja");
+  });
+
+  describe("setLocale / getLocale", () => {
+    it("デフォルトは ja", () => {
+      expect(getLocale()).toBe("ja");
+    });
+
+    it("en に切り替え可能", () => {
+      setLocale("en");
+      expect(getLocale()).toBe("en");
+    });
+
+    it("ja に戻せる", () => {
+      setLocale("en");
+      setLocale("ja");
+      expect(getLocale()).toBe("ja");
+    });
+  });
+
+  describe("t (メッセージ取得)", () => {
+    it("日本語メッセージを取得する", () => {
+      setLocale("ja");
+      const msg = t("error.snippet-not-found", { name: "test" });
+      expect(msg).toContain("test");
+      expect(msg).not.toBe("");
+    });
+
+    it("英語メッセージを取得する", () => {
+      setLocale("en");
+      const msg = t("error.snippet-not-found", { name: "test" });
+      expect(msg).toContain("test");
+      expect(msg).not.toBe("");
+    });
+
+    it("日英でメッセージが異なる", () => {
+      setLocale("ja");
+      const ja = t("error.snippet-not-found", { name: "x" });
+      setLocale("en");
+      const en = t("error.snippet-not-found", { name: "x" });
+      expect(ja).not.toBe(en);
+    });
+
+    it("パラメータが展開される", () => {
+      const msg = t("error.invalid-snippet-name", { name: "bad_name" });
+      expect(msg).toContain("bad_name");
+    });
+  });
+});

package/src/__tests__/remote-registry.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  fetchRegistryManifest,
+  listRemoteSnippets,
+  fetchSnippetDefinition,
+  fetchRemoteFiles,
+  fetchRemoteSnippet,
+  expandRemoteTemplateFiles,
+  clearAllRemoteRegistryCaches,
+} from "../remote-registry.js";
+import { RemoteRegistryFetchError, InvalidManifestError } from "../errors.js";
+
+const BASE_URL = "https://example.com/registry";
+
+const validManifest = {
+  snippets: {
+    "react-hook": { files: ["{{ name }}.ts", "{{ name }}.test.ts"] },
+    "express-api": { files: ["index.ts"] },
+  },
+};
+
+const reactHookYaml = `
+name: react-hook
+description: React カスタムフック雛形
+variables:
+  name:
+    description: フック名
+    schema:
+      type: string
+`;
+
+function mockFetch(handlers: Record<string, { status: number; body: string }>) {
+  return vi.fn(async (url: string) => {
+    const handler = handlers[url];
+    if (!handler) {
+      return { ok: false, status: 404, json: async () => ({}), text: async () => "" };
+    }
+    return {
+      ok: handler.status >= 200 && handler.status < 300,
+      status: handler.status,
+      json: async () => JSON.parse(handler.body),
+      text: async () => handler.body,
+    };
+  }) as unknown as typeof globalThis.fetch;
+}
+
+describe("fetchRegistryManifest", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    clearAllRemoteRegistryCaches();
+  });
+
+  it("正常なマニフェストを取得できる", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch({
+        [`${BASE_URL}/index.json`]: {
+          status: 200,
+          body: JSON.stringify(validManifest),
+        },
+      }),
+    );
+    const manifest = await fetchRegistryManifest(BASE_URL);
+    expect(manifest.snippets).toHaveProperty("react-hook");
+    expect(manifest.snippets["react-hook"].files).toHaveLength(2);
+  });
+
+  it("末尾スラッシュ付き URL でも取得できる", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch({
+        [`${BASE_URL}/index.json`]: {
+          status: 200,
+          body: JSON.stringify(validManifest),
+        },
+      }),
+    );
+    const manifest = await fetchRegistryManifest(`${BASE_URL}/`);
+    expect(manifest.snippets).toHaveProperty("react-hook");
+  });
+
+  it("HTTP エラーで RemoteRegistryFetchError", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch({
+        [`${BASE_URL}/index.json`]: { status: 500, body: "error" },
+      }),
+    );
+    await expect(fetchRegistryManifest(BASE_URL)).rejects.toThrow(
+      RemoteRegistryFetchError,
+    );
+  });
+
+  it("ネットワークエラーで RemoteRegistryFetchError", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => {
+        throw new TypeError("fetch failed");
+      }) as unknown as typeof globalThis.fetch,
+    );
+    await expect(fetchRegistryManifest(BASE_URL)).rejects.toThrow(
+      RemoteRegistryFetchError,
+    );
+  });
+
+  it("不正なマニフェストで InvalidManifestError", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch({
+        [`${BASE_URL}/index.json`]: {
+          status: 200,
+          body: JSON.stringify({ invalid: true }),
+        },
+      }),
+    );
+    await expect(fetchRegistryManifest(BASE_URL)).rejects.toThrow(
+      InvalidManifestError,
+    );
+  });
+});
+
+describe("listRemoteSnippets", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("snippet 名一覧を返す", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch({
+        [`${BASE_URL}/index.json`]: {
+          status: 200,
+          body: JSON.stringify(validManifest),
+        },
+      }),
+    );
+    const names = await listRemoteSnippets(BASE_URL);
+    expect(names).toEqual(["react-hook", "express-api"]);
+  });
+});
+
+describe("fetchSnippetDefinition", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("YAML を parse して SnippetDefinition を返す", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch({
+        [`${BASE_URL}/react-hook.yaml`]: {
+          status: 200,
+          body: reactHookYaml,
+        },
+      }),
+    );
+    const def = await fetchSnippetDefinition(BASE_URL, "react-hook");
+    expect(def.name).toBe("react-hook");
+    expect(def.variables).toHaveProperty("name");
+  });
+
+  it("404 で RemoteRegistryFetchError", async () => {
+    vi.stubGlobal("fetch", mockFetch({}));
+    await expect(
+      fetchSnippetDefinition(BASE_URL, "nonexistent"),
+    ).rejects.toThrow(RemoteRegistryFetchError);
+  });
+});
+
+describe("fetchRemoteFiles", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("テンプレートファイルを並列取得する", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch({
+        [`${BASE_URL}/react-hook/${encodeURIComponent("{{ name }}.ts")}`]: {
+          status: 200,
+          body: "export function {{ name }}() {}",
+        },
+        [`${BASE_URL}/react-hook/${encodeURIComponent("{{ name }}.test.ts")}`]:
+          {
+            status: 200,
+            body: 'test("{{ name }}", () => {});',
+          },
+      }),
+    );
+    const files = await fetchRemoteFiles(BASE_URL, "react-hook", [
+      "{{ name }}.ts",
+      "{{ name }}.test.ts",
+    ]);
+    expect(files.size).toBe(2);
+    expect(files.get("{{ name }}.ts")).toContain("{{ name }}");
+  });
+});
+
+describe("fetchRemoteSnippet", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("definition + files を統合して返す", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch({
+        [`${BASE_URL}/index.json`]: {
+          status: 200,
+          body: JSON.stringify(validManifest),
+        },
+        [`${BASE_URL}/react-hook.yaml`]: {
+          status: 200,
+          body: reactHookYaml,
+        },
+        [`${BASE_URL}/react-hook/${encodeURIComponent("{{ name }}.ts")}`]: {
+          status: 200,
+          body: "export function {{ name }}() {}",
+        },
+        [`${BASE_URL}/react-hook/${encodeURIComponent("{{ name }}.test.ts")}`]:
+          {
+            status: 200,
+            body: 'test("{{ name }}", () => {});',
+          },
+      }),
+    );
+    const snippet = await fetchRemoteSnippet(BASE_URL, "react-hook");
+    expect(snippet.definition.name).toBe("react-hook");
+    expect(snippet.files.size).toBe(2);
+  });
+
+  it("マニフェストに存在しない snippet は 404 エラー", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch({
+        [`${BASE_URL}/index.json`]: {
+          status: 200,
+          body: JSON.stringify(validManifest),
+        },
+      }),
+    );
+    await expect(
+      fetchRemoteSnippet(BASE_URL, "nonexistent"),
+    ).rejects.toThrow(RemoteRegistryFetchError);
+  });
+});
+
+describe("expandRemoteTemplateFiles", () => {
+  it("ファイルパスと内容の変数を展開する", () => {
+    const files = new Map([
+      ["{{ name }}.ts", "export function {{ name }}() {}"],
+      ["{{ name }}.test.ts", 'test("{{ name }}", () => {});'],
+    ]);
+    const expanded = expandRemoteTemplateFiles(files, { name: "useAuth" });
+    expect(expanded.has("useAuth.ts")).toBe(true);
+    expect(expanded.get("useAuth.ts")).toBe("export function useAuth() {}");
+    expect(expanded.has("useAuth.test.ts")).toBe(true);
+  });
+
+  it("変数が空の場合もそのまま展開する", () => {
+    const files = new Map([["index.ts", "console.log('hello');"]]);
+    const expanded = expandRemoteTemplateFiles(files, {});
+    expect(expanded.get("index.ts")).toBe("console.log('hello');");
+  });
+});