@tbsten/mir-core 0.0.1-alpha02

package/src/__tests__/snippet-schema.test.ts

@@ -0,0 +1,180 @@
+/**
+ * mir-core: snippet-schema の unit テスト
+ */
+import { describe, it, expect } from "vitest";
+import {
+  parseSnippetYaml,
+  serializeSnippetYaml,
+  validateSnippetDefinition,
+  ValidationError,
+} from "../index.js";
+
+// TODO: 現時点では理想の挙動をテストケースとして記述。後で有効化する。
+
+describe("parseSnippetYaml", () => {
+  it("最小限の YAML をパースできる", () => {
+    const def = parseSnippetYaml("name: my-snippet\n");
+    expect(def.name).toBe("my-snippet");
+  });
+
+  it("変数付き YAML をパースできる", () => {
+    const yaml = `
+name: react-hook
+description: React カスタムフック
+variables:
+  name:
+    description: フック名
+    schema:
+      type: string
+`;
+    const def = parseSnippetYaml(yaml);
+    expect(def.name).toBe("react-hook");
+    expect(def.variables?.name?.description).toBe("フック名");
+    expect(def.variables?.name?.schema?.type).toBe("string");
+  });
+
+  it("hooks 付き YAML をパースできる", () => {
+    const yaml = `
+name: test-snippet
+hooks:
+  before-install:
+    - echo: "Installing..."
+  after-install:
+    - echo: "Done!"
+`;
+    const def = parseSnippetYaml(yaml);
+    expect(def.hooks?.["before-install"]).toHaveLength(1);
+    expect(def.hooks?.["after-install"]).toHaveLength(1);
+  });
+
+  it("dependencies 付き YAML をパースできる", () => {
+    const yaml = `
+name: react-component
+description: React component
+dependencies:
+  - react-hook
+  - typescript-setup
+`;
+    const def = parseSnippetYaml(yaml);
+    expect(def.dependencies).toEqual(["react-hook", "typescript-setup"]);
+  });
+
+  it("不正な YAML でエラー", () => {
+    expect(() => parseSnippetYaml("not a yaml object: [")).toThrow();
+  });
+
+  it("name がない YAML でエラー", () => {
+    expect(() => parseSnippetYaml("description: no name\n")).toThrow(
+      ValidationError,
+    );
+  });
+});
+
+describe("serializeSnippetYaml", () => {
+  it("SnippetDefinition を YAML 文字列に変換する", () => {
+    const yaml = serializeSnippetYaml({ name: "test" });
+    expect(yaml).toContain("name: test");
+  });
+
+  it("パースと逆変換で元に戻る", () => {
+    const original = { name: "test", description: "desc" };
+    const yaml = serializeSnippetYaml(original);
+    const parsed = parseSnippetYaml(yaml);
+    expect(parsed.name).toBe(original.name);
+    expect(parsed.description).toBe(original.description);
+  });
+});
+
+describe("validateSnippetDefinition", () => {
+  it("最小限の定義はバリデーション通過", () => {
+    expect(() => validateSnippetDefinition({ name: "valid" })).not.toThrow();
+  });
+
+  it("name が空だとエラー", () => {
+    expect(() => validateSnippetDefinition({ name: "" })).toThrow(
+      ValidationError,
+    );
+  });
+
+  it("suggests が配列でないとエラー", () => {
+    expect(() =>
+      validateSnippetDefinition({
+        name: "test",
+        variables: {
+          key: { suggests: "not-array" as unknown as string[] },
+        },
+      }),
+    ).toThrow(ValidationError);
+  });
+
+  it("schema.type が不正だとエラー", () => {
+    expect(() =>
+      validateSnippetDefinition({
+        name: "test",
+        variables: {
+          key: {
+            schema: { type: "invalid" as "string" },
+          },
+        },
+      }),
+    ).toThrow(ValidationError);
+  });
+
+  it("正しい schema.type は通過 (string, number, boolean)", () => {
+    expect(() =>
+      validateSnippetDefinition({
+        name: "test",
+        variables: {
+          a: { schema: { type: "string" } },
+          b: { schema: { type: "number" } },
+          c: { schema: { type: "boolean" } },
+        },
+      }),
+    ).not.toThrow();
+  });
+
+  it("dependencies が配列の場合は通過", () => {
+    expect(() =>
+      validateSnippetDefinition({
+        name: "react-component",
+        dependencies: ["react-hook"],
+      }),
+    ).not.toThrow();
+  });
+
+  it("dependencies に複数要素を持つ場合は通過", () => {
+    expect(() =>
+      validateSnippetDefinition({
+        name: "test",
+        dependencies: ["dep1", "dep2", "dep3"],
+      }),
+    ).not.toThrow();
+  });
+
+  it("dependencies が配列でないとエラー", () => {
+    expect(() =>
+      validateSnippetDefinition({
+        name: "test",
+        dependencies: "not-array" as unknown as string[],
+      }),
+    ).toThrow(ValidationError);
+  });
+
+  it("dependencies の要素が文字列でないとエラー", () => {
+    expect(() =>
+      validateSnippetDefinition({
+        name: "test",
+        dependencies: ["valid-dep", 123 as unknown as string],
+      }),
+    ).toThrow(ValidationError);
+  });
+
+  it("dependencies の要素に不正な名前があるとエラー", () => {
+    expect(() =>
+      validateSnippetDefinition({
+        name: "test",
+        dependencies: ["-invalid-dep-name"],
+      }),
+    ).toThrow(ValidationError);
+  });
+});

package/src/__tests__/symlink-checker.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isSymbolicLink, findSymlinksInDirectory } from "../lib/symlink-checker.js";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mir-symlink-test-"));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("isSymbolicLink", () => {
+  it("通常のファイルに対して false を返す", () => {
+    const filePath = path.join(tmpDir, "regular.txt");
+    fs.writeFileSync(filePath, "content");
+    expect(isSymbolicLink(filePath)).toBe(false);
+  });
+
+  it("ディレクトリに対して false を返す", () => {
+    const dirPath = path.join(tmpDir, "subdir");
+    fs.mkdirSync(dirPath);
+    expect(isSymbolicLink(dirPath)).toBe(false);
+  });
+
+  it("シンボリックリンクに対して true を返す", () => {
+    const targetPath = path.join(tmpDir, "target.txt");
+    const linkPath = path.join(tmpDir, "link.txt");
+    fs.writeFileSync(targetPath, "content");
+    fs.symlinkSync(targetPath, linkPath);
+    expect(isSymbolicLink(linkPath)).toBe(true);
+  });
+
+  it("存在しないパスに対して false を返す", () => {
+    expect(isSymbolicLink(path.join(tmpDir, "nonexistent"))).toBe(false);
+  });
+});
+
+describe("findSymlinksInDirectory", () => {
+  it("シンボリックリンクがない場合 hasSymlinks=false を返す", () => {
+    fs.writeFileSync(path.join(tmpDir, "index.ts"), "content");
+    const result = findSymlinksInDirectory(tmpDir);
+    expect(result.hasSymlinks).toBe(false);
+    expect(result.symlinkPaths).toHaveLength(0);
+  });
+
+  it("シンボリックリンクを検出する", () => {
+    const targetPath = path.join(tmpDir, "target.txt");
+    const linkPath = path.join(tmpDir, "link.txt");
+    fs.writeFileSync(targetPath, "content");
+    fs.symlinkSync(targetPath, linkPath);
+
+    const result = findSymlinksInDirectory(tmpDir);
+    expect(result.hasSymlinks).toBe(true);
+    expect(result.symlinkPaths).toContain("link.txt");
+  });
+
+  it("サブディレクトリ内のシンボリックリンクを検出する", () => {
+    const subDir = path.join(tmpDir, "src");
+    fs.mkdirSync(subDir);
+    const targetPath = path.join(tmpDir, "target.txt");
+    const linkPath = path.join(subDir, "link.txt");
+    fs.writeFileSync(targetPath, "content");
+    fs.symlinkSync(targetPath, linkPath);
+
+    const result = findSymlinksInDirectory(tmpDir);
+    expect(result.hasSymlinks).toBe(true);
+    expect(result.symlinkPaths.some((p) => p.includes("link.txt"))).toBe(true);
+  });
+
+  it("複数のシンボリックリンクをすべて検出する", () => {
+    const target1 = path.join(tmpDir, "target1.txt");
+    const target2 = path.join(tmpDir, "target2.txt");
+    const link1 = path.join(tmpDir, "link1.txt");
+    const link2 = path.join(tmpDir, "link2.txt");
+    fs.writeFileSync(target1, "content1");
+    fs.writeFileSync(target2, "content2");
+    fs.symlinkSync(target1, link1);
+    fs.symlinkSync(target2, link2);
+
+    const result = findSymlinksInDirectory(tmpDir);
+    expect(result.hasSymlinks).toBe(true);
+    expect(result.symlinkPaths).toHaveLength(2);
+  });
+
+  it("存在しないディレクトリに対して空の結果を返す", () => {
+    const result = findSymlinksInDirectory(path.join(tmpDir, "nonexistent"));
+    expect(result.hasSymlinks).toBe(false);
+    expect(result.symlinkPaths).toHaveLength(0);
+  });
+});

package/src/__tests__/template-engine.test.ts

@@ -0,0 +1,137 @@
+/**
+ * mir-core: テンプレートエンジンの unit テスト
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  expandTemplate,
+  expandPath,
+  extractVariables,
+  extractVariablesFromDirectory,
+} from "../index.js";
+
+// TODO: 現時点では理想の挙動をテストケースとして記述。後で有効化する。
+
+describe("expandTemplate", () => {
+  it("変数を展開する", () => {
+    expect(expandTemplate("Hello, {{ name }}!", { name: "World" })).toBe(
+      "Hello, World!",
+    );
+  });
+
+  it("複数変数を展開する", () => {
+    const result = expandTemplate(
+      "{{ greeting }}, {{ name }}!",
+      { greeting: "Hi", name: "User" },
+    );
+    expect(result).toBe("Hi, User!");
+  });
+
+  it("変数が未定義の場合は空文字に展開", () => {
+    expect(expandTemplate("Hello, {{ name }}!", {})).toBe("Hello, !");
+  });
+
+  it("変数を含まないテンプレートはそのまま返す", () => {
+    expect(expandTemplate("plain text", {})).toBe("plain text");
+  });
+
+  it("空テンプレートは空文字を返す", () => {
+    expect(expandTemplate("", {})).toBe("");
+  });
+
+  it("Handlebars の #if ブロックを展開する", () => {
+    const template = "{{#if enabled}}ON{{else}}OFF{{/if}}";
+    expect(expandTemplate(template, { enabled: true })).toBe("ON");
+    expect(expandTemplate(template, { enabled: false })).toBe("OFF");
+  });
+
+  it("noEscape モードで HTML タグがエスケープされない", () => {
+    expect(expandTemplate("{{ html }}", { html: "<div>test</div>" })).toBe(
+      "<div>test</div>",
+    );
+  });
+});
+
+describe("expandPath", () => {
+  it("パス内の変数を展開する", () => {
+    expect(expandPath("{{ name }}.ts", { name: "useAuth" })).toBe("useAuth.ts");
+  });
+
+  it("ネストしたパスの変数を展開する", () => {
+    const result = expandPath("{{ dir }}/{{ name }}.ts", {
+      dir: "hooks",
+      name: "useAuth",
+    });
+    expect(result).toMatch(/hooks[/\\]useAuth\.ts/);
+  });
+
+  it("パス区切りを正規化する", () => {
+    const result = expandPath("a//b/c", {});
+    expect(result).not.toContain("//");
+  });
+});
+
+describe("extractVariables", () => {
+  it("単一変数を抽出する", () => {
+    expect(extractVariables("{{ name }}")).toContain("name");
+  });
+
+  it("複数変数を抽出する", () => {
+    const vars = extractVariables("{{ name }} {{ description }}");
+    expect(vars).toContain("name");
+    expect(vars).toContain("description");
+  });
+
+  it("重複変数は1つにまとめる", () => {
+    const vars = extractVariables("{{ name }} {{ name }}");
+    expect(vars.filter((v) => v === "name")).toHaveLength(1);
+  });
+
+  it("変数がない場合は空配列", () => {
+    expect(extractVariables("no variables")).toEqual([]);
+  });
+
+  it("#if ブロック内の変数を抽出する", () => {
+    const vars = extractVariables("{{#if enabled}}{{ name }}{{/if}}");
+    expect(vars).toContain("enabled");
+    expect(vars).toContain("name");
+  });
+});
+
+describe("extractVariablesFromDirectory", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mir-core-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("ファイル内容から変数を抽出する", () => {
+    fs.writeFileSync(path.join(tmpDir, "index.ts"), "export {{ name }}", "utf-8");
+    const vars = extractVariablesFromDirectory(tmpDir);
+    expect(vars).toContain("name");
+  });
+
+  it("ファイル名から変数を抽出する", () => {
+    fs.writeFileSync(path.join(tmpDir, "{{ name }}.ts"), "content", "utf-8");
+    const vars = extractVariablesFromDirectory(tmpDir);
+    expect(vars).toContain("name");
+  });
+
+  it("サブディレクトリ名から変数を抽出する", () => {
+    const subDir = path.join(tmpDir, "{{ module }}");
+    fs.mkdirSync(subDir, { recursive: true });
+    fs.writeFileSync(path.join(subDir, "index.ts"), "export {}", "utf-8");
+    const vars = extractVariablesFromDirectory(tmpDir);
+    expect(vars).toContain("module");
+  });
+
+  it("存在しないディレクトリは空配列", () => {
+    expect(extractVariablesFromDirectory("/nonexistent")).toEqual([]);
+  });
+});

package/src/__tests__/validate-name.test.ts

@@ -0,0 +1,61 @@
+/**
+ * mir-core: validateSnippetName の unit テスト
+ */
+import { describe, it, expect } from "vitest";
+import { validateSnippetName, ValidationError } from "../index.js";
+
+// TODO: 現時点では理想の挙動をテストケースとして記述。後で有効化する。
+
+describe("validateSnippetName", () => {
+  describe("正常系", () => {
+    it("英小文字のみ", () => {
+      expect(() => validateSnippetName("react")).not.toThrow();
+    });
+
+    it("英数字 + ハイフン", () => {
+      expect(() => validateSnippetName("react-hook")).not.toThrow();
+    });
+
+    it("数字始まり", () => {
+      expect(() => validateSnippetName("1component")).not.toThrow();
+    });
+
+    it("大文字含む", () => {
+      expect(() => validateSnippetName("MyComponent")).not.toThrow();
+    });
+
+    it("1文字", () => {
+      expect(() => validateSnippetName("a")).not.toThrow();
+    });
+  });
+
+  describe("異常系", () => {
+    it("空文字でエラー", () => {
+      expect(() => validateSnippetName("")).toThrow(ValidationError);
+    });
+
+    it("アンダースコアでエラー", () => {
+      expect(() => validateSnippetName("my_comp")).toThrow(ValidationError);
+    });
+
+    it("先頭ハイフンでエラー", () => {
+      expect(() => validateSnippetName("-invalid")).toThrow(ValidationError);
+    });
+
+    it("スペース含むとエラー", () => {
+      expect(() => validateSnippetName("my comp")).toThrow(ValidationError);
+    });
+
+    it("日本語でエラー", () => {
+      expect(() => validateSnippetName("テスト")).toThrow(ValidationError);
+    });
+
+    it("特殊文字でエラー", () => {
+      expect(() => validateSnippetName("react@hook")).toThrow(ValidationError);
+    });
+
+    it("ドット含むとエラー", () => {
+      expect(() => validateSnippetName("my.comp")).toThrow(ValidationError);
+    });
+  });
+});

package/src/errors.ts

@@ -0,0 +1,82 @@
+import { t } from "./i18n/index.js";
+
+export class MirError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "MirError";
+  }
+}
+
+export class ValidationError extends MirError {
+  constructor(message: string) {
+    super(message);
+    this.name = "ValidationError";
+  }
+}
+
+export class SnippetNotFoundError extends MirError {
+  readonly details: string;
+
+  constructor(name: string) {
+    super(t("error.snippet-not-found", { name }));
+    this.name = "SnippetNotFoundError";
+    this.details = t("error.snippet-not-found-details");
+  }
+}
+
+export class SnippetAlreadyExistsError extends MirError {
+  constructor(name: string) {
+    super(t("error.snippet-already-exists", { name }));
+    this.name = "SnippetAlreadyExistsError";
+  }
+}
+
+export class RegistryNotFoundError extends MirError {
+  constructor(name: string) {
+    super(t("error.registry-not-found", { name }));
+    this.name = "RegistryNotFoundError";
+  }
+}
+
+export class RegistryRemoteError extends MirError {
+  constructor(name?: string) {
+    super(
+      name
+        ? t("error.registry-remote-named", { name })
+        : t("error.registry-remote"),
+    );
+    this.name = "RegistryRemoteError";
+  }
+}
+
+export class PathTraversalError extends MirError {
+  constructor(filePath: string) {
+    super(t("error.path-traversal", { path: filePath }));
+    this.name = "PathTraversalError";
+  }
+}
+
+export class FileConflictError extends MirError {
+  constructor(filePath: string) {
+    super(t("error.file-conflict", { path: filePath }));
+    this.name = "FileConflictError";
+  }
+}
+
+export class RemoteRegistryFetchError extends MirError {
+  constructor(url: string, status?: number) {
+    super(
+      status
+        ? t("error.remote-fetch-status", { url, status })
+        : t("error.remote-fetch", { url }),
+    );
+    this.name = "RemoteRegistryFetchError";
+  }
+}
+
+export class InvalidManifestError extends MirError {
+  constructor(url: string) {
+    super(t("error.invalid-manifest", { url }));
+    this.name = "InvalidManifestError";
+  }
+}

package/src/hooks.ts

@@ -0,0 +1,63 @@
+import { MirError } from "./errors.js";
+import { expandTemplate } from "./template-engine.js";
+import { t } from "./i18n/index.js";
+import type { Action } from "./snippet-schema.js";
+
+export class ExitHookError extends MirError {
+  constructor() {
+    super(t("error.exit-hook"));
+    this.name = "ExitHookError";
+  }
+}
+
+export interface HookExecutionOptions {
+  onEcho?: (message: string) => void;
+}
+
+export function executeHooks(
+  actions: Action[],
+  variables: Record<string, unknown>,
+  options?: HookExecutionOptions,
+): Record<string, unknown> {
+  const vars = { ...variables };
+
+  for (const action of actions) {
+    if (action.echo !== undefined) {
+      const message = expandTemplate(action.echo, vars);
+      options?.onEcho?.(message);
+    }
+
+    if (action.exit !== undefined) {
+      if (action.if !== undefined) {
+        const condition = expandTemplate(action.if, vars);
+        if (isTruthy(condition)) {
+          throw new ExitHookError();
+        }
+      } else if (action.exit) {
+        throw new ExitHookError();
+      }
+    }
+
+    if (action.input !== undefined) {
+      for (const [, inputDef] of Object.entries(action.input)) {
+        const answerTo = inputDef["answer-to"];
+        if (!answerTo) continue;
+
+        if (inputDef.schema?.default !== undefined) {
+          vars[answerTo] = inputDef.schema.default;
+        } else {
+          throw new MirError(
+            t("error.hook-input-required", { key: answerTo }),
+          );
+        }
+      }
+    }
+  }
+
+  return vars;
+}
+
+function isTruthy(value: string): boolean {
+  const trimmed = value.trim();
+  return trimmed !== "" && trimmed !== "false" && trimmed !== "0";
+}

package/src/i18n/index.ts

@@ -0,0 +1,32 @@
+import type { MessageKey, MessageCatalog } from "./types.js";
+import { ja } from "./locales/ja.js";
+import { en } from "./locales/en.js";
+
+export type Locale = "ja" | "en";
+
+const catalogs: Record<Locale, MessageCatalog> = { ja, en };
+
+let currentLocale: Locale = "ja";
+
+export function setLocale(locale: Locale): void {
+  currentLocale = locale;
+}
+
+export function getLocale(): Locale {
+  return currentLocale;
+}
+
+export function t(
+  key: MessageKey,
+  params?: Record<string, string | number>,
+): string {
+  let message = catalogs[currentLocale][key];
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      message = message.replaceAll(`{${k}}`, String(v));
+    }
+  }
+  return message;
+}
+
+export type { MessageKey, MessageCatalog };