@tbsten/mir-core 0.0.2-alpha02 → 0.0.2-alpha03

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

@@ -1,180 +0,0 @@
-/**
- * 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

@@ -1,95 +0,0 @@
-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

@@ -1,240 +0,0 @@
-/**
- * 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("expandTemplate with helpers", () => {
-  it("lowercase ヘルパー", () => {
-    expect(expandTemplate("{{lowercase name}}", { name: "HELLO" })).toBe("hello");
-  });
-
-  it("uppercase ヘルパー", () => {
-    expect(expandTemplate("{{uppercase name}}", { name: "hello" })).toBe("HELLO");
-  });
-
-  it("replace ヘルパー", () => {
-    expect(
-      expandTemplate('{{replace package "/" "."}}', { package: "com/example/app" }),
-    ).toBe("com.example.app");
-  });
-
-  it("camelCase ヘルパー", () => {
-    expect(expandTemplate("{{camelCase name}}", { name: "my-component" })).toBe(
-      "myComponent",
-    );
-  });
-
-  it("pascalCase ヘルパー", () => {
-    expect(expandTemplate("{{pascalCase name}}", { name: "my-component" })).toBe(
-      "MyComponent",
-    );
-  });
-
-  it("snakeCase ヘルパー", () => {
-    expect(expandTemplate("{{snakeCase name}}", { name: "myComponent" })).toBe(
-      "my_component",
-    );
-  });
-
-  it("kebabCase ヘルパー", () => {
-    expect(expandTemplate("{{kebabCase name}}", { name: "MyComponent" })).toBe(
-      "my-component",
-    );
-  });
-
-  it("capitalize ヘルパー", () => {
-    expect(expandTemplate("{{capitalize name}}", { name: "hello" })).toBe("Hello");
-  });
-
-  it("uncapitalize ヘルパー", () => {
-    expect(expandTemplate("{{uncapitalize name}}", { name: "Hello" })).toBe("hello");
-  });
-
-  it("trim ヘルパー", () => {
-    expect(expandTemplate("{{trim name}}", { name: "  hello  " })).toBe("hello");
-  });
-
-  it("サブ式（ネスト）: lowercase(replace(...))", () => {
-    expect(
-      expandTemplate('{{lowercase (replace name "/" ".")}}', {
-        name: "COM/EXAMPLE/APP",
-      }),
-    ).toBe("com.example.app");
-  });
-
-  it("サブ式（ネスト）: pascalCase(replace(...))", () => {
-    expect(
-      expandTemplate('{{pascalCase (replace pkg "/" "-")}}', {
-        pkg: "my/cool/component",
-      }),
-    ).toBe("MyCoolComponent");
-  });
-});
-
-describe("extractVariables with helpers", () => {
-  it("ヘルパー名を変数に含めない", () => {
-    const vars = extractVariables("{{lowercase name}}");
-    expect(vars).toContain("name");
-    expect(vars).not.toContain("lowercase");
-  });
-
-  it("replace ヘルパーで変数のみ抽出", () => {
-    const vars = extractVariables('{{replace package "/" "."}}');
-    expect(vars).toContain("package");
-    expect(vars).not.toContain("replace");
-  });
-
-  it("サブ式でもヘルパー名を除外", () => {
-    const vars = extractVariables('{{lowercase (replace name "/" ".")}}');
-    expect(vars).toContain("name");
-    expect(vars).not.toContain("lowercase");
-    expect(vars).not.toContain("replace");
-  });
-
-  it("ヘルパーと通常変数が混在", () => {
-    const vars = extractVariables("{{name}} {{lowercase title}}");
-    expect(vars).toContain("name");
-    expect(vars).toContain("title");
-    expect(vars).not.toContain("lowercase");
-  });
-
-  it("組み込みヘルパー (if/each) も変数に含めない", () => {
-    const vars = extractVariables("{{#if enabled}}{{name}}{{/if}}");
-    expect(vars).toContain("enabled");
-    expect(vars).toContain("name");
-    expect(vars).not.toContain("if");
-  });
-});
-
-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

@@ -1,61 +0,0 @@
-/**
- * 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

@@ -1,82 +0,0 @@
-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/helpers/index.ts

@@ -1,34 +0,0 @@
-import type Handlebars from "handlebars";
-import * as helpers from "./string-helpers.js";
-
-/** ヘルパー名一覧（extractVariables でフィルタ用） */
-export const HELPER_NAMES: ReadonlySet<string> = new Set([
-  "lowercase",
-  "uppercase",
-  "capitalize",
-  "uncapitalize",
-  "replace",
-  "camelCase",
-  "pascalCase",
-  "snakeCase",
-  "kebabCase",
-  "trim",
-]);
-
-/** Handlebars インスタンスにヘルパーを一括登録 */
-export function registerHelpers(hbs: typeof Handlebars): void {
-  hbs.registerHelper("lowercase", (v: unknown) => helpers.lowercase(v));
-  hbs.registerHelper("uppercase", (v: unknown) => helpers.uppercase(v));
-  hbs.registerHelper("capitalize", (v: unknown) => helpers.capitalize(v));
-  hbs.registerHelper("uncapitalize", (v: unknown) => helpers.uncapitalize(v));
-  hbs.registerHelper(
-    "replace",
-    (v: unknown, search: unknown, replacement: unknown) =>
-      helpers.replace(v, search, replacement),
-  );
-  hbs.registerHelper("camelCase", (v: unknown) => helpers.camelCase(v));
-  hbs.registerHelper("pascalCase", (v: unknown) => helpers.pascalCase(v));
-  hbs.registerHelper("snakeCase", (v: unknown) => helpers.snakeCase(v));
-  hbs.registerHelper("kebabCase", (v: unknown) => helpers.kebabCase(v));
-  hbs.registerHelper("trim", (v: unknown) => helpers.trim(v));
-}