@simplysm/sd-cli 13.0.69 → 13.0.71

package/tests/run-watch.spec.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { filterPackagesByTargets } from "../src/utils/package-utils";
+import type { SdPackageConfig } from "../src/sd-config.types";
+
+describe("filterPackagesByTargets", () => {
+  const mockPackages: Record<string, SdPackageConfig | undefined> = {
+    "core-common": { target: "neutral" },
+    "core-node": { target: "node" },
+    "core-browser": { target: "browser" },
+    "solid-demo": { target: "client", server: 3000 },
+    "claude": { target: "scripts" },
+    "empty-pkg": undefined,
+  };
+
+  it("returns all packages except scripts when targets is empty", () => {
+    const result = filterPackagesByTargets(mockPackages, []);
+
+    expect(Object.keys(result)).toHaveLength(4);
+    expect(result["core-common"]).toBeDefined();
+    expect(result["core-node"]).toBeDefined();
+    expect(result["core-browser"]).toBeDefined();
+    expect(result["solid-demo"]).toBeDefined();
+    expect(result["claude"]).toBeUndefined();
+    expect(result["empty-pkg"]).toBeUndefined();
+  });
+
+  it("excludes scripts target even when specified in targets", () => {
+    const result = filterPackagesByTargets(mockPackages, ["claude"]);
+
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+
+  it("filters specific packages only", () => {
+    const result = filterPackagesByTargets(mockPackages, ["core-common", "core-node"]);
+
+    expect(Object.keys(result)).toHaveLength(2);
+    expect(result["core-common"]).toEqual({ target: "neutral" });
+    expect(result["core-node"]).toEqual({ target: "node" });
+  });
+
+  it("returns empty result when specifying non-existent package", () => {
+    const result = filterPackagesByTargets(mockPackages, ["non-existent"]);
+
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+
+  it("ignores undefined package config", () => {
+    const result = filterPackagesByTargets(mockPackages, ["empty-pkg"]);
+
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+
+  it("filters client target packages", () => {
+    const result = filterPackagesByTargets(mockPackages, ["solid-demo"]);
+
+    expect(Object.keys(result)).toHaveLength(1);
+    expect(result["solid-demo"]).toEqual({ target: "client", server: 3000 });
+  });
+
+  it("handles empty packages object", () => {
+    const result = filterPackagesByTargets({}, []);
+
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+
+  it("handles case where all packages are scripts", () => {
+    const scriptsOnly: Record<string, SdPackageConfig> = {
+      pkg1: { target: "scripts" },
+      pkg2: { target: "scripts" },
+    };
+    const result = filterPackagesByTargets(scriptsOnly, []);
+
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+});

package/tests/sd-cli.spec.ts

@@ -0,0 +1,330 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { consola, LogLevels } from "consola";
+
+// Mock runLint, runTypecheck, runWatch, runCheck
+vi.mock("../src/commands/lint", () => ({
+  runLint: vi.fn(),
+}));
+
+vi.mock("../src/commands/typecheck", () => ({
+  runTypecheck: vi.fn(),
+}));
+
+vi.mock("../src/commands/check", () => ({
+  runCheck: vi.fn(),
+}));
+
+vi.mock("../src/commands/watch", () => ({
+  runWatch: vi.fn(),
+}));
+
+vi.mock("../src/commands/build", () => ({
+  runBuild: vi.fn(),
+}));
+
+vi.mock("../src/commands/publish", () => ({
+  runPublish: vi.fn(),
+}));
+
+import { createCliParser } from "../src/sd-cli-entry";
+import { runLint } from "../src/commands/lint";
+import { runTypecheck } from "../src/commands/typecheck";
+import { runCheck } from "../src/commands/check";
+import { runWatch } from "../src/commands/watch";
+import { runBuild } from "../src/commands/build";
+import { runPublish } from "../src/commands/publish";
+
+describe("sd-cli", () => {
+  let originalConsolaLevel: number;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(runLint).mockResolvedValue(undefined);
+    vi.mocked(runTypecheck).mockResolvedValue(undefined);
+    vi.mocked(runCheck).mockResolvedValue(undefined);
+    vi.mocked(runWatch).mockResolvedValue(undefined);
+    vi.mocked(runBuild).mockResolvedValue(undefined);
+    vi.mocked(runPublish).mockResolvedValue(undefined);
+    originalConsolaLevel = consola.level;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    consola.level = originalConsolaLevel;
+  });
+
+  describe("lint command", () => {
+    it("calls runLint with correct options", async () => {
+      await createCliParser(["lint", "packages/core-common", "--fix"]).parse();
+
+      expect(runLint).toHaveBeenCalledWith({
+        targets: ["packages/core-common"],
+        fix: true,
+        timing: false,
+      });
+    });
+
+    it("passes --timing option correctly", async () => {
+      await createCliParser(["lint", "--timing"]).parse();
+
+      expect(runLint).toHaveBeenCalledWith({
+        targets: [],
+        fix: false,
+        timing: true,
+      });
+    });
+
+    it("runs lint command without targets", async () => {
+      await createCliParser(["lint"]).parse();
+
+      expect(runLint).toHaveBeenCalledWith({
+        targets: [],
+        fix: false,
+        timing: false,
+      });
+    });
+  });
+
+  describe("typecheck command", () => {
+    it("calls runTypecheck with correct options", async () => {
+      await createCliParser(["typecheck", "packages/cli"]).parse();
+
+      expect(runTypecheck).toHaveBeenCalledWith({
+        targets: ["packages/cli"],
+        options: [],
+      });
+    });
+
+    it("passes multiple targets to typecheck command", async () => {
+      await createCliParser(["typecheck", "packages/core-common", "packages/core-node"]).parse();
+
+      expect(runTypecheck).toHaveBeenCalledWith({
+        targets: ["packages/core-common", "packages/core-node"],
+        options: [],
+      });
+    });
+
+    it("passes --options option correctly", async () => {
+      await createCliParser(["typecheck", "-o", "dev", "-o", "test"]).parse();
+
+      expect(runTypecheck).toHaveBeenCalledWith({
+        targets: [],
+        options: ["dev", "test"],
+      });
+    });
+  });
+
+  describe("check command", () => {
+    it("calls runCheck with correct options", async () => {
+      await createCliParser(["check", "packages/core-common", "--type", "typecheck,lint"]).parse();
+
+      expect(runCheck).toHaveBeenCalledWith({
+        targets: ["packages/core-common"],
+        types: ["typecheck", "lint"],
+      });
+    });
+
+    it("runs check command without targets", async () => {
+      await createCliParser(["check"]).parse();
+
+      expect(runCheck).toHaveBeenCalledWith({
+        targets: [],
+        types: ["typecheck", "lint", "test"],
+      });
+    });
+
+    it("specifies single type using --type option", async () => {
+      await createCliParser(["check", "--type", "test"]).parse();
+
+      expect(runCheck).toHaveBeenCalledWith({
+        targets: [],
+        types: ["test"],
+      });
+    });
+  });
+
+  describe("watch command", () => {
+    it("calls runWatch with correct options", async () => {
+      await createCliParser(["watch", "solid"]).parse();
+
+      expect(runWatch).toHaveBeenCalledWith({
+        targets: ["solid"],
+        options: [],
+      });
+    });
+
+    it("passes multiple targets to watch command", async () => {
+      await createCliParser(["watch", "solid", "solid-demo"]).parse();
+
+      expect(runWatch).toHaveBeenCalledWith({
+        targets: ["solid", "solid-demo"],
+        options: [],
+      });
+    });
+
+    it("runs watch command without targets", async () => {
+      await createCliParser(["watch"]).parse();
+
+      expect(runWatch).toHaveBeenCalledWith({
+        targets: [],
+        options: [],
+      });
+    });
+
+    it("passes --options option correctly", async () => {
+      await createCliParser(["watch", "-o", "dev"]).parse();
+
+      expect(runWatch).toHaveBeenCalledWith({
+        targets: [],
+        options: ["dev"],
+      });
+    });
+  });
+
+  describe("build command", () => {
+    it("calls runBuild with correct options", async () => {
+      await createCliParser(["build", "solid", "core-common"]).parse();
+
+      expect(runBuild).toHaveBeenCalledWith({
+        targets: ["solid", "core-common"],
+        options: [],
+      });
+    });
+
+    it("runs build command without targets", async () => {
+      await createCliParser(["build"]).parse();
+
+      expect(runBuild).toHaveBeenCalledWith({
+        targets: [],
+        options: [],
+      });
+    });
+
+    it("passes --options option correctly", async () => {
+      await createCliParser(["build", "-o", "prod"]).parse();
+
+      expect(runBuild).toHaveBeenCalledWith({
+        targets: [],
+        options: ["prod"],
+      });
+    });
+  });
+
+  describe("publish command", () => {
+    it("calls runPublish with correct options", async () => {
+      await createCliParser(["publish", "solid", "core-common"]).parse();
+
+      expect(runPublish).toHaveBeenCalledWith({
+        targets: ["solid", "core-common"],
+        noBuild: false,
+        dryRun: false,
+        options: [],
+      });
+    });
+
+    it("runs publish command without targets", async () => {
+      await createCliParser(["publish"]).parse();
+
+      expect(runPublish).toHaveBeenCalledWith({
+        targets: [],
+        noBuild: false,
+        dryRun: false,
+        options: [],
+      });
+    });
+
+    it("passes --no-build option correctly", async () => {
+      await createCliParser(["publish", "--no-build"]).parse();
+
+      expect(runPublish).toHaveBeenCalledWith({
+        targets: [],
+        noBuild: true,
+        dryRun: false,
+        options: [],
+      });
+    });
+
+    it("passes --options option correctly", async () => {
+      await createCliParser(["publish", "-o", "prod", "-o", "test"]).parse();
+
+      expect(runPublish).toHaveBeenCalledWith({
+        targets: [],
+        noBuild: false,
+        dryRun: false,
+        options: ["prod", "test"],
+      });
+    });
+
+    it("passes all options together", async () => {
+      await createCliParser(["publish", "solid", "--no-build", "-o", "prod"]).parse();
+
+      expect(runPublish).toHaveBeenCalledWith({
+        targets: ["solid"],
+        noBuild: true,
+        dryRun: false,
+        options: ["prod"],
+      });
+    });
+
+    it("passes --dry-run option correctly", async () => {
+      await createCliParser(["publish", "--dry-run"]).parse();
+
+      expect(runPublish).toHaveBeenCalledWith({
+        targets: [],
+        noBuild: false,
+        dryRun: true,
+        options: [],
+      });
+    });
+
+    it("uses --dry-run with other options together", async () => {
+      await createCliParser(["publish", "solid", "--dry-run", "-o", "prod"]).parse();
+
+      expect(runPublish).toHaveBeenCalledWith({
+        targets: ["solid"],
+        noBuild: false,
+        dryRun: true,
+        options: ["prod"],
+      });
+    });
+  });
+
+  describe("global --debug option", () => {
+    it("sets consola.level to debug with --debug option", async () => {
+      await createCliParser(["--debug", "lint"]).parse();
+
+      expect(consola.level).toBe(LogLevels.debug);
+    });
+
+    it("does not change consola.level without --debug", async () => {
+      const levelBefore = consola.level;
+      await createCliParser(["lint"]).parse();
+
+      expect(consola.level).toBe(levelBefore);
+    });
+  });
+
+  describe("error handling", () => {
+    it("throws error on unknown command", async () => {
+      let errorMessage: string | undefined;
+      const parser = createCliParser(["unknown"]).fail((msg) => {
+        errorMessage = msg;
+      });
+
+      await parser.parse();
+
+      expect(errorMessage).toMatch(/Unknown argument/);
+    });
+
+    it("throws error when no command specified", async () => {
+      let errorMessage: string | undefined;
+      const parser = createCliParser([]).fail((msg) => {
+        errorMessage = msg;
+      });
+
+      await parser.parse();
+
+      expect(errorMessage).toMatch(/Please specify a command/);
+    });
+  });
+});

package/tests/tailwind-config-deps.spec.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import path from "path";
+import { getTailwindConfigDeps } from "../src/utils/tailwind-config-deps";
+
+const packagesDir = path.resolve(import.meta.dirname, "../..");
+
+describe("getTailwindConfigDeps", () => {
+  it("includes solid tailwind config in dependencies of solid-demo tailwind config", () => {
+    const configPath = path.join(packagesDir, "solid-demo/tailwind.config.ts");
+    const deps = getTailwindConfigDeps(configPath, ["@simplysm"]);
+
+    const solidConfig = path.join(packagesDir, "solid/tailwind.config.ts");
+    expect(deps).toContain(solidConfig);
+  });
+
+  it("includes the config itself in dependencies", () => {
+    const configPath = path.join(packagesDir, "solid-demo/tailwind.config.ts");
+    const deps = getTailwindConfigDeps(configPath, ["@simplysm"]);
+
+    expect(deps).toContain(path.resolve(configPath));
+  });
+
+  it("excludes packages outside @simplysm/ (like tailwindcss/colors)", () => {
+    const configPath = path.join(packagesDir, "solid/tailwind.config.ts");
+    const deps = getTailwindConfigDeps(configPath, ["@simplysm"]);
+
+    // solid/tailwind.config.ts imports tailwindcss/colors but does not track it
+    expect(deps).toHaveLength(1); // only itself
+  });
+});

package/tests/template.spec.ts

@@ -0,0 +1,70 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import path from "path";
+import os from "os";
+import fs from "fs";
+import { renderTemplateDir } from "../src/utils/template";
+
+describe("renderTemplateDir", () => {
+  let tmpDir: string;
+  let srcDir: string;
+  let destDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-template-test-"));
+    srcDir = path.join(tmpDir, "src");
+    destDir = path.join(tmpDir, "dest");
+    fs.mkdirSync(srcDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  test("renders .hbs files with context and removes .hbs extension", async () => {
+    fs.writeFileSync(path.join(srcDir, "hello.txt.hbs"), "Hello, {{name}}!");
+    await renderTemplateDir(srcDir, destDir, { name: "World" });
+    expect(fs.readFileSync(path.join(destDir, "hello.txt"), "utf-8")).toBe("Hello, World!");
+  });
+
+  test("copies non-.hbs files as-is (binary safe)", async () => {
+    const binaryData = Uint8Array.from([0x00, 0x01, 0xff, 0xfe]);
+    fs.writeFileSync(path.join(srcDir, "icon.bin"), binaryData);
+    await renderTemplateDir(srcDir, destDir, {});
+    const copied = fs.readFileSync(path.join(destDir, "icon.bin"));
+    expect(new Uint8Array(copied)).toEqual(binaryData);
+  });
+
+  test("replaces directory name placeholders", async () => {
+    const subDir = path.join(srcDir, "__CLIENT__");
+    fs.mkdirSync(subDir, { recursive: true });
+    fs.writeFileSync(path.join(subDir, "file.txt.hbs"), "pkg: {{clientName}}");
+    await renderTemplateDir(
+      srcDir,
+      destDir,
+      { clientName: "client-admin" },
+      { __CLIENT__: "client-admin" },
+    );
+    expect(fs.readFileSync(path.join(destDir, "client-admin", "file.txt"), "utf-8")).toBe(
+      "pkg: client-admin",
+    );
+  });
+
+  test("skips file when .hbs renders to empty/whitespace", async () => {
+    fs.writeFileSync(path.join(srcDir, "optional.ts.hbs"), "{{#if enabled}}content{{/if}}");
+    await renderTemplateDir(srcDir, destDir, { enabled: false });
+    expect(fs.existsSync(path.join(destDir, "optional.ts"))).toBe(false);
+  });
+
+  test("handles nested directories", async () => {
+    fs.mkdirSync(path.join(srcDir, "a", "b"), { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "a", "b", "deep.txt.hbs"), "{{value}}");
+    await renderTemplateDir(srcDir, destDir, { value: "nested" });
+    expect(fs.readFileSync(path.join(destDir, "a", "b", "deep.txt"), "utf-8")).toBe("nested");
+  });
+
+  test("preserves Handlebars {{#if}} conditional blocks", async () => {
+    fs.writeFileSync(path.join(srcDir, "test.txt.hbs"), "start\n{{#if flag}}included\n{{/if}}end");
+    await renderTemplateDir(srcDir, destDir, { flag: true });
+    expect(fs.readFileSync(path.join(destDir, "test.txt"), "utf-8")).toBe("start\nincluded\nend");
+  });
+});

package/tests/utils/rebuild-manager.spec.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi } from "vitest";
+import { consola } from "consola";
+import { RebuildManager } from "../../src/utils/rebuild-manager";
+
+describe("RebuildManager", () => {
+  it("logs start/success messages on rebuild batch", async () => {
+    const logger = consola.withTag("test");
+    const startSpy = vi.spyOn(logger, "start");
+    const successSpy = vi.spyOn(logger, "success");
+
+    const manager = new RebuildManager(logger);
+
+    const resolver = manager.registerBuild("pkg1:build", "pkg1 (node)");
+
+    // resolve to complete the build
+    resolver();
+
+    // wait for _runBatch microtask + Promise.allSettled
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(startSpy).toHaveBeenCalledWith("Rebuilding... (pkg1 (node))");
+    expect(successSpy).toHaveBeenCalledWith("Rebuild completed (pkg1 (node))");
+  });
+
+  it("batches multiple builds and logs them together", async () => {
+    const logger = consola.withTag("test");
+    const startSpy = vi.spyOn(logger, "start");
+    const successSpy = vi.spyOn(logger, "success");
+
+    const manager = new RebuildManager(logger);
+
+    const resolver1 = manager.registerBuild("pkg1:build", "pkg1 (node)");
+    const resolver2 = manager.registerBuild("pkg2:build", "pkg2 (browser)");
+
+    resolver1();
+    resolver2();
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(startSpy).toHaveBeenCalledWith("Rebuilding... (pkg1 (node), pkg2 (browser))");
+    expect(successSpy).toHaveBeenCalledWith("Rebuild completed (pkg1 (node), pkg2 (browser))");
+  });
+});

package/tests/write-changed-output-files.spec.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import path from "path";
+import os from "os";
+import fs from "fs/promises";
+import type esbuild from "esbuild";
+import { writeChangedOutputFiles } from "../src/utils/esbuild-config";
+
+function makeOutputFile(filePath: string, text: string): esbuild.OutputFile {
+  const contents = new TextEncoder().encode(text);
+  return { path: filePath, contents, text, hash: "" };
+}
+
+describe("writeChangedOutputFiles", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "esbuild-write-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("writes new files that don't exist on disk", async () => {
+    const outFile = makeOutputFile(path.join(tmpDir, "index.js"), "const x = 1;\n");
+    await writeChangedOutputFiles([outFile]);
+
+    const result = await fs.readFile(path.join(tmpDir, "index.js"), "utf-8");
+    expect(result).toBe("const x = 1;\n");
+  });
+
+  it("skips writing when content is identical", async () => {
+    const filePath = path.join(tmpDir, "index.js");
+    await fs.writeFile(filePath, "const x = 1;\n");
+    const statBefore = await fs.stat(filePath);
+
+    // Small delay to ensure mtime would differ if file were rewritten
+    await new Promise((r) => setTimeout(r, 50));
+
+    const outFile = makeOutputFile(filePath, "const x = 1;\n");
+    await writeChangedOutputFiles([outFile]);
+
+    const statAfter = await fs.stat(filePath);
+    expect(statAfter.mtimeMs).toBe(statBefore.mtimeMs);
+  });
+
+  it("writes when content differs", async () => {
+    const filePath = path.join(tmpDir, "index.js");
+    await fs.writeFile(filePath, "const x = 1;\n");
+
+    const outFile = makeOutputFile(filePath, "const x = 2;\n");
+    await writeChangedOutputFiles([outFile]);
+
+    const result = await fs.readFile(filePath, "utf-8");
+    expect(result).toBe("const x = 2;\n");
+  });
+
+  it("adds .js extension to relative imports in .js files", async () => {
+    const filePath = path.join(tmpDir, "index.js");
+    const outFile = makeOutputFile(filePath, 'import { foo } from "./utils";\nexport { foo };\n');
+    await writeChangedOutputFiles([outFile]);
+
+    const result = await fs.readFile(filePath, "utf-8");
+    expect(result).toBe('import { foo } from "./utils.js";\nexport { foo };\n');
+  });
+
+  it("does not add .js extension to imports that already have known extensions", async () => {
+    const filePath = path.join(tmpDir, "index.js");
+    const outFile = makeOutputFile(
+      filePath,
+      'import "./styles.css";\nimport data from "./data.json";\n',
+    );
+    await writeChangedOutputFiles([outFile]);
+
+    const result = await fs.readFile(filePath, "utf-8");
+    expect(result).toBe('import "./styles.css";\nimport data from "./data.json";\n');
+  });
+
+  it("does not rewrite imports in .js.map files", async () => {
+    const filePath = path.join(tmpDir, "index.js.map");
+    const content = '{"sources":["./utils"]}';
+    const outFile = makeOutputFile(filePath, content);
+    await writeChangedOutputFiles([outFile]);
+
+    const result = await fs.readFile(filePath, "utf-8");
+    expect(result).toBe(content);
+  });
+
+  it("creates parent directories if needed", async () => {
+    const filePath = path.join(tmpDir, "sub", "deep", "index.js");
+    const outFile = makeOutputFile(filePath, "export {};\n");
+    await writeChangedOutputFiles([outFile]);
+
+    const result = await fs.readFile(filePath, "utf-8");
+    expect(result).toBe("export {};\n");
+  });
+});