@pulse-editor/cli 0.1.10 → 0.1.11

package/dist/components/header.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 export default function Header() {
-    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [_jsx(Text, { color: 'whiteBright', children: "Pulse Editor CLI" }), _jsx(Text, { children: "Version: 0.0.1" }), _jsx(Text, { color: 'blueBright', children: "https://pulse-editor.com" })] }));
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [_jsx(Text, { color: 'whiteBright', children: "Palmos CLI" }), _jsx(Text, { children: "Version: 0.0.1" }), _jsx(Text, { color: 'blueBright', children: "https://pulse-editor.com" })] }));
 }

package/dist/lib/__tests__/backend-url.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/backend-url.test.js

@@ -0,0 +1,10 @@
+import { describe, it, expect } from "vitest";
+import { getBackendUrl } from "../backend-url.js";
+describe("getBackendUrl", () => {
+    it("should return localhost URL when stage is true", () => {
+        expect(getBackendUrl(true)).toBe("https://localhost:8080");
+    });
+    it("should return production URL when stage is false", () => {
+        expect(getBackendUrl(false)).toBe("https://pulse-editor.com");
+    });
+});

package/dist/lib/__tests__/cli-flags.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/cli-flags.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { flags } from "../cli-flags.js";
+describe("flags", () => {
+    it("should define all expected flags", () => {
+        expect(flags.token).toBeDefined();
+        expect(flags.flow).toBeDefined();
+        expect(flags.framework).toBeDefined();
+        expect(flags.stage).toBeDefined();
+        expect(flags.name).toBeDefined();
+        expect(flags.visibility).toBeDefined();
+        expect(flags.target).toBeDefined();
+        expect(flags.beta).toBeDefined();
+        expect(flags.build).toBeDefined();
+        expect(flags.path).toBeDefined();
+        expect(flags.displayName).toBeDefined();
+        expect(flags.description).toBeDefined();
+        expect(flags.continue).toBeDefined();
+    });
+    it("should have correct types", () => {
+        expect(flags.token.type).toBe("boolean");
+        expect(flags.framework.type).toBe("string");
+        expect(flags.stage.type).toBe("boolean");
+        expect(flags.name.type).toBe("string");
+    });
+    it("should have correct defaults", () => {
+        expect(flags.stage.default).toBe(false);
+        expect(flags.build.default).toBe(true);
+        expect(flags.continue.default).toBe(false);
+    });
+    it("should have correct short flags", () => {
+        expect(flags.framework.shortFlag).toBe("f");
+        expect(flags.name.shortFlag).toBe("n");
+        expect(flags.visibility.shortFlag).toBe("v");
+        expect(flags.target.shortFlag).toBe("t");
+        expect(flags.path.shortFlag).toBe("p");
+        expect(flags.description.shortFlag).toBe("d");
+    });
+});

package/dist/lib/__tests__/manual.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/manual.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "vitest";
+import { commandsManual } from "../manual.js";
+describe("commandsManual", () => {
+    it("should have all expected commands", () => {
+        const expectedCommands = [
+            "help",
+            "chat",
+            "code",
+            "login",
+            "logout",
+            "publish",
+            "create",
+            "preview",
+            "dev",
+            "build",
+            "start",
+            "clean",
+            "upgrade",
+            "skill",
+        ];
+        for (const cmd of expectedCommands) {
+            expect(commandsManual).toHaveProperty(cmd);
+        }
+    });
+    it("should have non-empty string values", () => {
+        for (const [key, value] of Object.entries(commandsManual)) {
+            expect(typeof value).toBe("string");
+            expect(value.length).toBeGreaterThan(0);
+        }
+    });
+});

package/dist/lib/__tests__/token.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/token.test.js

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { saveToken, getToken, isTokenInEnv, checkToken } from "../token.js";
+vi.mock("fs", () => ({
+    default: {
+        existsSync: vi.fn(),
+        readFileSync: vi.fn(),
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+    },
+}));
+vi.mock("os", () => ({
+    default: {
+        homedir: vi.fn(() => "/home/testuser"),
+    },
+}));
+vi.mock("../backend-url.js", () => ({
+    getBackendUrl: vi.fn((stage) => stage ? "https://localhost:8080" : "https://pulse-editor.com"),
+}));
+import fs from "fs";
+describe("saveToken", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should create config dir if it does not exist and save prod token", () => {
+        vi.mocked(fs.existsSync).mockReturnValueOnce(false).mockReturnValueOnce(false);
+        vi.mocked(fs.readFileSync).mockReturnValue("{}");
+        saveToken("my-token", false);
+        expect(fs.mkdirSync).toHaveBeenCalled();
+        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining("config.json"), expect.stringContaining('"accessToken": "my-token"'));
+    });
+    it("should save dev token when devMode is true", () => {
+        vi.mocked(fs.existsSync).mockReturnValueOnce(false).mockReturnValueOnce(true);
+        saveToken("dev-token", true);
+        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), expect.stringContaining('"devAccessToken": "dev-token"'));
+    });
+    it("should merge with existing config", () => {
+        vi.mocked(fs.existsSync).mockReturnValueOnce(true).mockReturnValueOnce(true);
+        vi.mocked(fs.readFileSync).mockReturnValue('{"existingKey": "value"}');
+        saveToken("new-token", false);
+        const written = vi.mocked(fs.writeFileSync).mock.calls[0][1];
+        const parsed = JSON.parse(written);
+        expect(parsed.existingKey).toBe("value");
+        expect(parsed.accessToken).toBe("new-token");
+    });
+});
+describe("getToken", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.env = { ...originalEnv };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it("should return env var PE_ACCESS_TOKEN when set", () => {
+        process.env["PE_ACCESS_TOKEN"] = "env-token";
+        expect(getToken(false)).toBe("env-token");
+    });
+    it("should return env var PE_DEV_ACCESS_TOKEN when devMode", () => {
+        process.env["PE_DEV_ACCESS_TOKEN"] = "dev-env-token";
+        expect(getToken(true)).toBe("dev-env-token");
+    });
+    it("should read from config file when env not set", () => {
+        delete process.env["PE_ACCESS_TOKEN"];
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue('{"accessToken": "file-token"}');
+        expect(getToken(false)).toBe("file-token");
+    });
+    it("should return undefined when no env and no file", () => {
+        delete process.env["PE_ACCESS_TOKEN"];
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        expect(getToken(false)).toBeUndefined();
+    });
+    it("should handle malformed JSON gracefully", () => {
+        delete process.env["PE_ACCESS_TOKEN"];
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue("not json");
+        vi.spyOn(console, "error").mockImplementation(() => { });
+        expect(getToken(false)).toBeUndefined();
+    });
+    it("should return devAccessToken in dev mode from file", () => {
+        delete process.env["PE_DEV_ACCESS_TOKEN"];
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue('{"devAccessToken": "dev-file-token"}');
+        expect(getToken(true)).toBe("dev-file-token");
+    });
+});
+describe("isTokenInEnv", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it("should return true when PE_ACCESS_TOKEN is set", () => {
+        process.env["PE_ACCESS_TOKEN"] = "token";
+        expect(isTokenInEnv(false)).toBe(true);
+    });
+    it("should return false when PE_ACCESS_TOKEN is not set", () => {
+        delete process.env["PE_ACCESS_TOKEN"];
+        expect(isTokenInEnv(false)).toBe(false);
+    });
+    it("should check PE_DEV_ACCESS_TOKEN in dev mode", () => {
+        process.env["PE_DEV_ACCESS_TOKEN"] = "dev-token";
+        expect(isTokenInEnv(true)).toBe(true);
+    });
+});
+describe("checkToken", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should return true on 200 status", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({ status: 200 });
+        const result = await checkToken("valid-token", false);
+        expect(result).toBe(true);
+        expect(fetch).toHaveBeenCalledWith("https://pulse-editor.com/api/api-keys/check", expect.objectContaining({
+            method: "POST",
+            body: JSON.stringify({ token: "valid-token" }),
+        }));
+    });
+    it("should return false on non-200 status", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({ status: 401 });
+        const result = await checkToken("bad-token", false);
+        expect(result).toBe(false);
+    });
+    it("should use stage URL in dev mode", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({ status: 200 });
+        await checkToken("token", true);
+        expect(fetch).toHaveBeenCalledWith("https://localhost:8080/api/api-keys/check", expect.any(Object));
+    });
+});

package/dist/lib/__tests__/types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/types.test.js

@@ -0,0 +1,10 @@
+import { describe, it, expect } from "vitest";
+// types.ts only exports a type, which doesn't generate runtime code.
+// Import something from the file to register it for coverage.
+describe("types", () => {
+    it("should export Item type (compile-time only)", async () => {
+        // This is a type-only file, importing it registers coverage
+        const mod = await import("../types.js");
+        expect(mod).toBeDefined();
+    });
+});

package/dist/lib/backend/__tests__/publish-app.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/backend/__tests__/publish-app.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { publishApp } from "../publish-app.js";
+vi.mock("fs", () => ({
+    default: {
+        readFileSync: vi.fn(),
+    },
+}));
+vi.mock("../../token.js", () => ({
+    getToken: vi.fn(() => "test-token"),
+}));
+vi.mock("../../backend-url.js", () => ({
+    getBackendUrl: vi.fn((stage) => stage ? "https://localhost:8080" : "https://pulse-editor.com"),
+}));
+import fs from "fs";
+describe("publishApp", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        globalThis.fetch = vi.fn().mockResolvedValue({ status: 200 });
+    });
+    it("should read config and zip, then POST to publish endpoint", async () => {
+        vi.mocked(fs.readFileSync)
+            .mockReturnValueOnce('{"visibility": "public"}')
+            .mockReturnValueOnce(Buffer.from("fake-zip"));
+        const res = await publishApp(false);
+        expect(fetch).toHaveBeenCalledWith("https://pulse-editor.com/api/app/publish", expect.objectContaining({
+            method: "POST",
+            headers: expect.objectContaining({
+                Authorization: "Bearer test-token",
+            }),
+        }));
+        expect(res.status).toBe(200);
+    });
+    it("should use stage URL when isStage is true", async () => {
+        vi.mocked(fs.readFileSync)
+            .mockReturnValueOnce('{"visibility": "private"}')
+            .mockReturnValueOnce(Buffer.from("fake-zip"));
+        await publishApp(true);
+        expect(fetch).toHaveBeenCalledWith("https://localhost:8080/api/app/publish", expect.any(Object));
+    });
+});

package/dist/lib/execa-utils/__tests__/clean.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/execa-utils/__tests__/clean.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { cleanDist } from "../clean.js";
+vi.mock("execa", () => ({
+    execa: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("../deps.js", () => ({
+    getDepsBinPath: vi.fn(() => "npx rimraf"),
+}));
+import { execa } from "execa";
+describe("cleanDist", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.spyOn(console, "log").mockImplementation(() => { });
+    });
+    it("should call execa with rimraf dist", async () => {
+        await cleanDist();
+        expect(execa).toHaveBeenCalledWith("npx rimraf dist", { shell: true });
+    });
+    it("should log cleaning messages", async () => {
+        await cleanDist();
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining("Cleaning dist"));
+    });
+});

package/dist/lib/execa-utils/__tests__/deps.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/execa-utils/__tests__/deps.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { getDepsBinPath } from "../deps.js";
+vi.mock("fs", () => ({
+    default: {
+        existsSync: vi.fn(),
+    },
+}));
+import fs from "fs";
+describe("getDepsBinPath", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should return npx when package exists in local node_modules", () => {
+        vi.mocked(fs.existsSync).mockReturnValueOnce(true);
+        expect(getDepsBinPath("rimraf")).toBe("npx rimraf");
+    });
+    it("should return full path with .cmd on Windows", () => {
+        vi.mocked(fs.existsSync).mockReturnValueOnce(false).mockReturnValueOnce(true);
+        const originalPlatform = process.platform;
+        Object.defineProperty(process, "platform", { value: "win32" });
+        const result = getDepsBinPath("rimraf");
+        expect(result).toContain("rimraf.cmd");
+        expect(result).toContain("@pulse-editor/cli/node_modules/.bin/");
+        Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+    it("should return full path without .cmd on non-Windows", () => {
+        vi.mocked(fs.existsSync).mockReturnValueOnce(false).mockReturnValueOnce(true);
+        const originalPlatform = process.platform;
+        Object.defineProperty(process, "platform", { value: "linux" });
+        const result = getDepsBinPath("rimraf");
+        expect(result).toContain("@pulse-editor/cli/node_modules/.bin/rimraf");
+        expect(result).not.toContain(".cmd");
+        Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+    it("should throw when dependency not found", () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        expect(() => getDepsBinPath("nonexistent")).toThrow("Dependency nonexistent not found.");
+    });
+});

package/dist/lib/webpack/__tests__/compile.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/webpack/__tests__/compile.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { webpackCompile } from "../compile.js";
+vi.mock("webpack", () => {
+    const mockCompiler = {
+        run: vi.fn((cb) => cb(null)),
+        watch: vi.fn((_opts, cb) => cb(null)),
+    };
+    const webpack = vi.fn(() => mockCompiler);
+    return { default: webpack, __mockCompiler: mockCompiler };
+});
+vi.mock("../configs/utils.js", () => ({
+    generateTempTsConfig: vi.fn(),
+}));
+vi.mock("../webpack-config.js", () => ({
+    createWebpackConfig: vi.fn().mockResolvedValue([{ name: "config" }]),
+}));
+import webpack from "webpack";
+import { generateTempTsConfig } from "../configs/utils.js";
+import { createWebpackConfig } from "../webpack-config.js";
+describe("webpackCompile", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should call generateTempTsConfig", async () => {
+        await webpackCompile("production");
+        expect(generateTempTsConfig).toHaveBeenCalled();
+    });
+    it("should pass correct params for production mode", async () => {
+        await webpackCompile("production");
+        expect(createWebpackConfig).toHaveBeenCalledWith(false, "both", "production");
+    });
+    it("should pass correct params for development mode", async () => {
+        await webpackCompile("development");
+        expect(createWebpackConfig).toHaveBeenCalledWith(false, "both", "development");
+    });
+    it("should pass correct params for preview mode", async () => {
+        await webpackCompile("preview");
+        expect(createWebpackConfig).toHaveBeenCalledWith(true, "both", "development");
+    });
+    it("should pass buildTarget when specified", async () => {
+        await webpackCompile("production", "client");
+        expect(createWebpackConfig).toHaveBeenCalledWith(false, "client", "production");
+    });
+    it("should return compiler in watch mode", async () => {
+        const result = await webpackCompile("development", undefined, true);
+        expect(result).toBeDefined();
+        const mockCompiler = webpack().__proto__; // just verify it returns
+    });
+    it("should handle webpack run errors", async () => {
+        const { __mockCompiler } = await import("webpack");
+        __mockCompiler.run.mockImplementationOnce((cb) => cb(new Error("build error")));
+        await expect(webpackCompile("production")).rejects.toThrow("build error");
+    });
+    it("should log error when watch mode has errors", async () => {
+        vi.spyOn(console, "error").mockImplementation(() => { });
+        const { __mockCompiler } = await import("webpack");
+        __mockCompiler.watch.mockImplementationOnce((_opts, cb) => cb(new Error("watch error")));
+        const result = await webpackCompile("development", undefined, true);
+        expect(result).toBeDefined();
+        expect(console.error).toHaveBeenCalledWith(expect.stringContaining("Webpack build failed"), expect.any(Error));
+    });
+});

package/dist/lib/webpack/__tests__/webpack-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/webpack/__tests__/webpack-config.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createWebpackConfig } from "../webpack-config.js";
+vi.mock("../configs/mf-client.js", () => ({
+    makeMFClientConfig: vi.fn().mockResolvedValue({ name: "client-config" }),
+}));
+vi.mock("../configs/mf-server.js", () => ({
+    makeMFServerConfig: vi.fn().mockResolvedValue({ name: "server-config" }),
+}));
+vi.mock("../configs/preview.js", () => ({
+    makePreviewClientConfig: vi
+        .fn()
+        .mockResolvedValue({ name: "preview-config" }),
+}));
+import { makeMFClientConfig } from "../configs/mf-client.js";
+import { makeMFServerConfig } from "../configs/mf-server.js";
+import { makePreviewClientConfig } from "../configs/preview.js";
+describe("createWebpackConfig", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should return preview + server configs when isPreview", async () => {
+        const result = await createWebpackConfig(true, "both", "development");
+        expect(result).toHaveLength(2);
+        expect(makePreviewClientConfig).toHaveBeenCalledWith("development");
+        expect(makeMFServerConfig).toHaveBeenCalledWith("development");
+    });
+    it("should return only server config when buildTarget is server", async () => {
+        const result = await createWebpackConfig(false, "server", "production");
+        expect(result).toHaveLength(1);
+        expect(makeMFServerConfig).toHaveBeenCalledWith("production");
+        expect(makeMFClientConfig).not.toHaveBeenCalled();
+    });
+    it("should return only client config when buildTarget is client", async () => {
+        const result = await createWebpackConfig(false, "client", "production");
+        expect(result).toHaveLength(1);
+        expect(makeMFClientConfig).toHaveBeenCalledWith("production");
+        expect(makeMFServerConfig).not.toHaveBeenCalled();
+    });
+    it("should return both configs when buildTarget is both", async () => {
+        const result = await createWebpackConfig(false, "both", "development");
+        expect(result).toHaveLength(2);
+        expect(makeMFClientConfig).toHaveBeenCalledWith("development");
+        expect(makeMFServerConfig).toHaveBeenCalledWith("development");
+    });
+});

package/dist/lib/webpack/configs/__tests__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/webpack/configs/__tests__/utils.test.js

@@ -0,0 +1,691 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { getLocalNetworkIP, discoverServerFunctions, normalizeJSDocPropertyName, getActionType, isPromiseLikeType, unwrapPromiseLikeType, parseTypeDefs, generateTempTsConfig, readConfigFile, discoverAppSkillActions, compileAppActionSkills, } from "../utils.js";
+vi.mock("os", () => ({
+    networkInterfaces: vi.fn(),
+}));
+vi.mock("glob", () => ({
+    globSync: vi.fn(),
+}));
+vi.mock("fs", () => ({
+    existsSync: vi.fn(),
+    writeFileSync: vi.fn(),
+}));
+vi.mock("fs/promises", () => ({
+    default: {
+        access: vi.fn(),
+        readFile: vi.fn(),
+        copyFile: vi.fn(),
+        rm: vi.fn(),
+    },
+}));
+// Mock ts-morph for discoverAppSkillActions and compileAppActionSkills
+const mockGetName = vi.fn().mockReturnValue("testAction");
+const mockGetText = vi.fn().mockReturnValue("initializer");
+const mockGetInitializer = vi.fn().mockReturnValue({ getText: mockGetText });
+const mockBindingElement = {
+    getName: mockGetName,
+    getInitializer: mockGetInitializer,
+    getKind: vi.fn().mockReturnValue(208), // BindingElement
+};
+const mockNameNode = {
+    getElements: vi.fn().mockReturnValue([]),
+};
+const mockFuncParam = {
+    getNameNode: vi.fn().mockReturnValue(mockNameNode),
+    getType: vi.fn().mockReturnValue({
+        getProperties: vi.fn().mockReturnValue([]),
+    }),
+};
+const mockFuncDecl = {
+    getName: vi.fn().mockReturnValue("testAction"),
+    getJsDocs: vi.fn().mockReturnValue([
+        {
+            getDescription: vi.fn().mockReturnValue("A test action"),
+            getFullText: vi.fn().mockReturnValue("/** A test action */"),
+        },
+    ]),
+    getParameters: vi.fn().mockReturnValue([]),
+    getReturnType: vi.fn().mockReturnValue({
+        isObject: vi.fn().mockReturnValue(true),
+        getProperties: vi.fn().mockReturnValue([]),
+        getSymbol: vi.fn().mockReturnValue(null),
+        getTypeArguments: vi.fn().mockReturnValue([]),
+    }),
+    getKind: vi.fn().mockReturnValue(272), // FunctionDeclaration
+    asKind: vi.fn().mockReturnThis(),
+    asKindOrThrow: vi.fn().mockReturnThis(),
+};
+const mockSourceFile = {
+    getDefaultExportSymbol: vi.fn().mockReturnValue({
+        getDeclarations: vi.fn().mockReturnValue([mockFuncDecl]),
+    }),
+    getDescendantsOfKind: vi.fn().mockReturnValue([]),
+};
+vi.mock("ts-morph", () => {
+    class MockProject {
+        addSourceFileAtPath = vi.fn().mockReturnValue(mockSourceFile);
+        constructor(_opts) { }
+    }
+    return {
+        Project: MockProject,
+        Node: {
+            isObjectBindingPattern: vi.fn().mockReturnValue(false),
+            isBindingElement: vi.fn().mockReturnValue(false),
+        },
+        SyntaxKind: {
+            FunctionDeclaration: 272,
+            JSDoc: 348,
+        },
+    };
+});
+import { networkInterfaces } from "os";
+import { globSync } from "glob";
+import { existsSync, writeFileSync } from "fs";
+describe("getLocalNetworkIP", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should return first non-internal IPv4 address", () => {
+        vi.mocked(networkInterfaces).mockReturnValue({
+            eth0: [
+                {
+                    address: "192.168.1.100",
+                    family: "IPv4",
+                    internal: false,
+                    netmask: "255.255.255.0",
+                    mac: "00:00:00:00:00:00",
+                    cidr: "192.168.1.100/24",
+                },
+            ],
+        });
+        expect(getLocalNetworkIP()).toBe("192.168.1.100");
+    });
+    it("should skip internal addresses", () => {
+        vi.mocked(networkInterfaces).mockReturnValue({
+            lo: [
+                {
+                    address: "127.0.0.1",
+                    family: "IPv4",
+                    internal: true,
+                    netmask: "255.0.0.0",
+                    mac: "00:00:00:00:00:00",
+                    cidr: "127.0.0.1/8",
+                },
+            ],
+        });
+        expect(getLocalNetworkIP()).toBe("localhost");
+    });
+    it("should skip IPv6 addresses", () => {
+        vi.mocked(networkInterfaces).mockReturnValue({
+            eth0: [
+                {
+                    address: "::1",
+                    family: "IPv6",
+                    internal: false,
+                    netmask: "ffff:ffff:ffff:ffff::",
+                    mac: "00:00:00:00:00:00",
+                    cidr: "::1/128",
+                    scopeid: 0,
+                },
+            ],
+        });
+        expect(getLocalNetworkIP()).toBe("localhost");
+    });
+    it("should return localhost when no interfaces", () => {
+        vi.mocked(networkInterfaces).mockReturnValue({});
+        expect(getLocalNetworkIP()).toBe("localhost");
+    });
+});
+describe("discoverServerFunctions", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should map server function files to entry points", () => {
+        vi.mocked(globSync).mockReturnValue([
+            "src/server-function/hello.ts",
+            "src/server-function/utils/helper.ts",
+        ]);
+        const result = discoverServerFunctions();
+        expect(result).toEqual({
+            "./hello": "./src/server-function/hello.ts",
+            "./utils/helper": "./src/server-function/utils/helper.ts",
+        });
+    });
+    it("should handle backslash paths (Windows)", () => {
+        vi.mocked(globSync).mockReturnValue([
+            "src\\server-function\\hello.ts",
+        ]);
+        const result = discoverServerFunctions();
+        expect(result).toEqual({
+            "./hello": "./src/server-function/hello.ts",
+        });
+    });
+    it("should return empty object when no files", () => {
+        vi.mocked(globSync).mockReturnValue([]);
+        const result = discoverServerFunctions();
+        expect(result).toEqual({});
+    });
+});
+describe("normalizeJSDocPropertyName", () => {
+    it("should remove brackets and defaults", () => {
+        expect(normalizeJSDocPropertyName("[name=default]")).toBe("name");
+    });
+    it("should handle plain name", () => {
+        expect(normalizeJSDocPropertyName("name")).toBe("name");
+    });
+    it("should return empty for undefined", () => {
+        expect(normalizeJSDocPropertyName(undefined)).toBe("");
+    });
+    it("should handle brackets without default", () => {
+        expect(normalizeJSDocPropertyName("[optional]")).toBe("optional");
+    });
+    it("should trim whitespace", () => {
+        expect(normalizeJSDocPropertyName("  name  ")).toBe("name");
+    });
+});
+describe("getActionType", () => {
+    beforeEach(() => {
+        vi.spyOn(console, "warn").mockImplementation(() => { });
+    });
+    it("should return string for 'string'", () => {
+        expect(getActionType("string")).toBe("string");
+    });
+    it("should return number for 'number'", () => {
+        expect(getActionType("number")).toBe("number");
+    });
+    it("should return boolean for 'boolean'", () => {
+        expect(getActionType("boolean")).toBe("boolean");
+    });
+    it("should return object for 'any'", () => {
+        expect(getActionType("any")).toBe("object");
+    });
+    it("should handle arrays", () => {
+        expect(getActionType("string[]")).toEqual(["string"]);
+    });
+    it("should handle nested arrays", () => {
+        expect(getActionType("number[][]")).toEqual([["number"]]);
+    });
+    it("should return undefined for empty string", () => {
+        expect(getActionType("")).toBe("undefined");
+    });
+    it("should return the text and warn for unknown types", () => {
+        expect(getActionType("CustomType")).toBe("CustomType");
+        expect(console.warn).toHaveBeenCalled();
+    });
+});
+describe("isPromiseLikeType", () => {
+    it("should return true for Promise type", () => {
+        const mockType = {
+            getSymbol: () => ({ getName: () => "Promise" }),
+        };
+        expect(isPromiseLikeType(mockType)).toBe(true);
+    });
+    it("should return true for PromiseLike type", () => {
+        const mockType = {
+            getSymbol: () => ({ getName: () => "PromiseLike" }),
+        };
+        expect(isPromiseLikeType(mockType)).toBe(true);
+    });
+    it("should return false for other types", () => {
+        const mockType = {
+            getSymbol: () => ({ getName: () => "Observable" }),
+        };
+        expect(isPromiseLikeType(mockType)).toBe(false);
+    });
+    it("should return false when no symbol", () => {
+        const mockType = { getSymbol: () => undefined };
+        expect(isPromiseLikeType(mockType)).toBe(false);
+    });
+});
+describe("unwrapPromiseLikeType", () => {
+    it("should unwrap Promise type argument", () => {
+        const innerType = { text: "string" };
+        const mockType = {
+            getSymbol: () => ({ getName: () => "Promise" }),
+            getTypeArguments: () => [innerType],
+        };
+        expect(unwrapPromiseLikeType(mockType)).toBe(innerType);
+    });
+    it("should return original type if not Promise", () => {
+        const mockType = {
+            getSymbol: () => ({ getName: () => "Observable" }),
+            getTypeArguments: () => [],
+        };
+        expect(unwrapPromiseLikeType(mockType)).toBe(mockType);
+    });
+    it("should return original type if Promise has no type args", () => {
+        const mockType = {
+            getSymbol: () => ({ getName: () => "Promise" }),
+            getTypeArguments: () => [],
+        };
+        expect(unwrapPromiseLikeType(mockType)).toBe(mockType);
+    });
+});
+describe("parseTypeDefs", () => {
+    it("should parse typedef and property from JSDoc", () => {
+        const mockDoc = {
+            getFullText: () => `/**
+ * @typedef {Object} input
+ * @property {string} name - The name of the user
+ * @property {number} age - The age
+ */`,
+        };
+        const result = parseTypeDefs([mockDoc]);
+        expect(result["input"]).toBeDefined();
+        expect(result["input"]["name"]).toEqual({
+            type: "string",
+            description: "The name of the user",
+        });
+        expect(result["input"]["age"]).toEqual({
+            type: "number",
+            description: "The age",
+        });
+    });
+    it("should handle optional properties with brackets", () => {
+        const mockDoc = {
+            getFullText: () => `/**
+ * @typedef {Object} input
+ * @property {string} [name=default] - Optional name
+ */`,
+        };
+        const result = parseTypeDefs([mockDoc]);
+        expect(result["input"]["name"]).toEqual({
+            type: "string",
+            description: "Optional name",
+        });
+    });
+    it("should return empty for no typedefs", () => {
+        const mockDoc = {
+            getFullText: () => `/** Just a comment */`,
+        };
+        const result = parseTypeDefs([mockDoc]);
+        expect(result).toEqual({});
+    });
+    it("should handle multiple typedefs in multiple docs", () => {
+        const mockDoc1 = {
+            getFullText: () => `/**
+ * @typedef {Object} input
+ * @property {string} name - The name
+ */`,
+        };
+        const mockDoc2 = {
+            getFullText: () => `/**
+ * @typedef {Object} output
+ * @property {number} count - The count
+ */`,
+        };
+        const result = parseTypeDefs([mockDoc1, mockDoc2]);
+        expect(result["input"]).toBeDefined();
+        expect(result["output"]).toBeDefined();
+    });
+});
+describe("generateTempTsConfig", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should skip if config already exists", () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        generateTempTsConfig();
+        expect(writeFileSync).not.toHaveBeenCalled();
+    });
+    it("should write tsconfig if it does not exist", () => {
+        vi.mocked(existsSync).mockReturnValue(false);
+        generateTempTsConfig();
+        expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining("tsconfig.server.json"), expect.stringContaining("ES2020"));
+    });
+});
+describe("readConfigFile", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should read and parse config file", async () => {
+        const fsPromises = (await import("fs/promises")).default;
+        vi.mocked(fsPromises.access).mockResolvedValue(undefined);
+        vi.mocked(fsPromises.readFile).mockResolvedValue('{"id": "test-app", "version": "1.0.0"}');
+        const result = await readConfigFile();
+        expect(result).toEqual({ id: "test-app", version: "1.0.0" });
+    });
+    it("should retry when file does not exist yet", async () => {
+        const fsPromises = (await import("fs/promises")).default;
+        let callCount = 0;
+        vi.mocked(fsPromises.access).mockImplementation(async () => {
+            callCount++;
+            if (callCount < 3)
+                throw new Error("ENOENT");
+        });
+        vi.mocked(fsPromises.readFile).mockResolvedValue('{"id": "test"}');
+        const result = await readConfigFile();
+        expect(result).toEqual({ id: "test" });
+        expect(callCount).toBe(3);
+    });
+});
+describe("discoverAppSkillActions", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.spyOn(console, "warn").mockImplementation(() => { });
+    });
+    it("should map skill action files to entry points", () => {
+        vi.mocked(globSync).mockReturnValue([
+            "src/skill/myAction/action.ts",
+        ]);
+        const result = discoverAppSkillActions();
+        expect(result).toEqual({
+            "./skill/myAction": "./src/skill/myAction/action.ts",
+        });
+    });
+    it("should return empty object when no skill files", () => {
+        vi.mocked(globSync).mockReturnValue([]);
+        const result = discoverAppSkillActions();
+        expect(result).toEqual({});
+    });
+    it("should skip files without default export", () => {
+        vi.mocked(globSync).mockReturnValue([
+            "src/skill/myAction/action.ts",
+        ]);
+        mockSourceFile.getDefaultExportSymbol.mockReturnValueOnce(null);
+        const result = discoverAppSkillActions();
+        expect(result).toEqual({});
+    });
+});
+describe("compileAppActionSkills", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.spyOn(console, "warn").mockImplementation(() => { });
+    });
+    it("should compile simple action with no params and no returns", () => {
+        vi.mocked(globSync).mockReturnValue([
+            "src/skill/testAction/action.ts",
+        ]);
+        // Reset mockFuncDecl for this test
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("A test action"),
+                getFullText: vi.fn().mockReturnValue("/** A test action */"),
+            },
+        ]);
+        mockFuncDecl.getParameters.mockReturnValue([]);
+        mockFuncDecl.getReturnType.mockReturnValue({
+            isObject: vi.fn().mockReturnValue(true),
+            getProperties: vi.fn().mockReturnValue([]),
+            getSymbol: vi.fn().mockReturnValue(null),
+            getTypeArguments: vi.fn().mockReturnValue([]),
+        });
+        mockFuncDecl.getKind.mockReturnValue(272);
+        mockSourceFile.getDescendantsOfKind.mockReturnValue([]);
+        const config = {};
+        const result = compileAppActionSkills(config);
+        expect(result.actions).toHaveLength(1);
+        expect(result.actions[0].name).toBe("testAction");
+        expect(result.actions[0].description).toContain("test action");
+    });
+    it("should throw when action has no JSDoc description", () => {
+        vi.mocked(globSync).mockReturnValue([
+            "src/skill/noDoc/action.ts",
+        ]);
+        mockFuncDecl.getJsDocs.mockReturnValue([]);
+        expect(() => compileAppActionSkills({})).toThrow("missing a JSDoc description");
+    });
+    it("should skip files without default export", () => {
+        vi.mocked(globSync).mockReturnValue([
+            "src/skill/noExport/action.ts",
+        ]);
+        mockSourceFile.getDefaultExportSymbol.mockReturnValueOnce(null);
+        const config = {};
+        const result = compileAppActionSkills(config);
+        expect(result.actions).toHaveLength(0);
+    });
+    it("should skip when return type is not object", () => {
+        vi.mocked(globSync).mockReturnValue([
+            "src/skill/testAction/action.ts",
+        ]);
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("desc"),
+                getFullText: vi.fn().mockReturnValue("/** desc */"),
+            },
+        ]);
+        mockFuncDecl.getReturnType.mockReturnValue({
+            isObject: vi.fn().mockReturnValue(false),
+            getProperties: vi.fn().mockReturnValue([]),
+            getSymbol: vi.fn().mockReturnValue(null),
+            getTypeArguments: vi.fn().mockReturnValue([]),
+        });
+        const config = {};
+        const result = compileAppActionSkills(config);
+        expect(result.actions).toHaveLength(0);
+    });
+    it("should throw when params exist but no input typedef", () => {
+        vi.mocked(globSync).mockReturnValue(["src/skill/testAction/action.ts"]);
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("desc"),
+                getFullText: vi.fn().mockReturnValue("/** desc */"),
+            },
+        ]);
+        const mockProp = {
+            getName: vi.fn().mockReturnValue("name"),
+            isOptional: vi.fn().mockReturnValue(false),
+            getTypeAtLocation: vi.fn().mockReturnValue({ getText: () => "string" }),
+        };
+        const mockParam = {
+            getNameNode: vi.fn().mockReturnValue({ getElements: vi.fn().mockReturnValue([]) }),
+            getType: vi.fn().mockReturnValue({
+                getProperties: vi.fn().mockReturnValue([mockProp]),
+            }),
+        };
+        mockFuncDecl.getParameters.mockReturnValue([mockParam]);
+        mockSourceFile.getDescendantsOfKind.mockReturnValue([]); // no typedefs
+        expect(() => compileAppActionSkills({})).toThrow('missing an');
+    });
+    it("should compile action with params and input typedef", () => {
+        vi.mocked(globSync).mockReturnValue(["src/skill/testAction/action.ts"]);
+        const jsdocText = `/**
+ * A test action
+ * @typedef {Object} input
+ * @property {string} name - User name
+ */`;
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("A test action"),
+                getFullText: vi.fn().mockReturnValue(jsdocText),
+            },
+        ]);
+        mockSourceFile.getDescendantsOfKind.mockReturnValue([
+            { getFullText: () => jsdocText },
+        ]);
+        const mockProp = {
+            getName: vi.fn().mockReturnValue("name"),
+            isOptional: vi.fn().mockReturnValue(false),
+            getTypeAtLocation: vi.fn().mockReturnValue({ getText: () => "string" }),
+        };
+        const mockParam = {
+            getNameNode: vi.fn().mockReturnValue({ getElements: vi.fn().mockReturnValue([]) }),
+            getType: vi.fn().mockReturnValue({
+                getProperties: vi.fn().mockReturnValue([mockProp]),
+            }),
+        };
+        mockFuncDecl.getParameters.mockReturnValue([mockParam]);
+        mockFuncDecl.getReturnType.mockReturnValue({
+            isObject: vi.fn().mockReturnValue(true),
+            getProperties: vi.fn().mockReturnValue([]),
+            getSymbol: vi.fn().mockReturnValue(null),
+            getTypeArguments: vi.fn().mockReturnValue([]),
+        });
+        const config = {};
+        const result = compileAppActionSkills(config);
+        expect(result.actions).toHaveLength(1);
+        expect(result.actions[0].parameters).toHaveProperty("name");
+        expect(result.actions[0].parameters.name.type).toBe("string");
+    });
+    it("should throw on missing property in input typedef", () => {
+        vi.mocked(globSync).mockReturnValue(["src/skill/testAction/action.ts"]);
+        const jsdocText = `/**
+ * A test action
+ * @typedef {Object} input
+ * @property {string} other - Other field
+ */`;
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("A test action"),
+                getFullText: vi.fn().mockReturnValue(jsdocText),
+            },
+        ]);
+        mockSourceFile.getDescendantsOfKind.mockReturnValue([
+            { getFullText: () => jsdocText },
+        ]);
+        const mockProp = {
+            getName: vi.fn().mockReturnValue("name"),
+            isOptional: vi.fn().mockReturnValue(false),
+        };
+        const mockParam = {
+            getNameNode: vi.fn().mockReturnValue({ getElements: vi.fn().mockReturnValue([]) }),
+            getType: vi.fn().mockReturnValue({
+                getProperties: vi.fn().mockReturnValue([mockProp]),
+            }),
+        };
+        mockFuncDecl.getParameters.mockReturnValue([mockParam]);
+        expect(() => compileAppActionSkills({})).toThrow('missing');
+    });
+    it("should compile action with return properties and output typedef", () => {
+        vi.mocked(globSync).mockReturnValue(["src/skill/testAction/action.ts"]);
+        const jsdocText = `/**
+ * A test action
+ * @typedef {Object} output
+ * @property {string} result - The result
+ */`;
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("A test action"),
+                getFullText: vi.fn().mockReturnValue(jsdocText),
+            },
+        ]);
+        mockSourceFile.getDescendantsOfKind.mockReturnValue([
+            { getFullText: () => jsdocText },
+        ]);
+        mockFuncDecl.getParameters.mockReturnValue([]);
+        const retProp = {
+            getName: vi.fn().mockReturnValue("result"),
+            isOptional: vi.fn().mockReturnValue(false),
+            getTypeAtLocation: vi.fn().mockReturnValue({ getText: () => "string" }),
+        };
+        mockFuncDecl.getReturnType.mockReturnValue({
+            isObject: vi.fn().mockReturnValue(true),
+            getProperties: vi.fn().mockReturnValue([retProp]),
+            getSymbol: vi.fn().mockReturnValue(null),
+            getTypeArguments: vi.fn().mockReturnValue([]),
+        });
+        const config = {};
+        const result = compileAppActionSkills(config);
+        expect(result.actions).toHaveLength(1);
+        expect(result.actions[0].returns).toHaveProperty("result");
+    });
+    it("should throw on return props without output typedef (non-promise)", () => {
+        vi.mocked(globSync).mockReturnValue(["src/skill/testAction/action.ts"]);
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("desc"),
+                getFullText: vi.fn().mockReturnValue("/** desc */"),
+            },
+        ]);
+        mockSourceFile.getDescendantsOfKind.mockReturnValue([]);
+        mockFuncDecl.getParameters.mockReturnValue([]);
+        const retProp = {
+            getName: vi.fn().mockReturnValue("result"),
+            isOptional: vi.fn().mockReturnValue(false),
+            getTypeAtLocation: vi.fn().mockReturnValue({ getText: () => "string" }),
+        };
+        mockFuncDecl.getReturnType.mockReturnValue({
+            isObject: vi.fn().mockReturnValue(true),
+            getProperties: vi.fn().mockReturnValue([retProp]),
+            getSymbol: vi.fn().mockReturnValue(null),
+            getTypeArguments: vi.fn().mockReturnValue([]),
+        });
+        expect(() => compileAppActionSkills({})).toThrow('missing');
+    });
+    it("should warn and fallback for Promise return without output typedef", () => {
+        vi.mocked(globSync).mockReturnValue(["src/skill/testAction/action.ts"]);
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("desc"),
+                getFullText: vi.fn().mockReturnValue("/** desc */"),
+            },
+        ]);
+        mockSourceFile.getDescendantsOfKind.mockReturnValue([]);
+        mockFuncDecl.getParameters.mockReturnValue([]);
+        const retProp = {
+            getName: vi.fn().mockReturnValue("data"),
+            isOptional: vi.fn().mockReturnValue(true),
+            getTypeAtLocation: vi.fn().mockReturnValue({ getText: () => "string" }),
+        };
+        mockFuncDecl.getReturnType.mockReturnValue({
+            isObject: vi.fn().mockReturnValue(true),
+            getProperties: vi.fn().mockReturnValue([retProp]),
+            getSymbol: vi.fn().mockReturnValue({ getName: () => "Promise" }),
+            getTypeArguments: vi.fn().mockReturnValue([
+                {
+                    isObject: vi.fn().mockReturnValue(true),
+                    getProperties: vi.fn().mockReturnValue([retProp]),
+                    getSymbol: vi.fn().mockReturnValue(null),
+                    getTypeArguments: vi.fn().mockReturnValue([]),
+                },
+            ]),
+        });
+        const config = {};
+        const result = compileAppActionSkills(config);
+        expect(result.actions).toHaveLength(1);
+        expect(result.actions[0].returns).toHaveProperty("data");
+        expect(result.actions[0].returns.data.optional).toBe(true);
+        expect(console.warn).toHaveBeenCalledWith(expect.stringContaining("Falling back to TypeScript-inferred"));
+    });
+    it("should throw on missing output property in output typedef", () => {
+        vi.mocked(globSync).mockReturnValue(["src/skill/testAction/action.ts"]);
+        const jsdocText = `/**
+ * A test action
+ * @typedef {Object} output
+ * @property {string} other - Other field
+ */`;
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("desc"),
+                getFullText: vi.fn().mockReturnValue(jsdocText),
+            },
+        ]);
+        mockSourceFile.getDescendantsOfKind.mockReturnValue([
+            { getFullText: () => jsdocText },
+        ]);
+        mockFuncDecl.getParameters.mockReturnValue([]);
+        const retProp = {
+            getName: vi.fn().mockReturnValue("missing"),
+            isOptional: vi.fn().mockReturnValue(false),
+            getTypeAtLocation: vi.fn().mockReturnValue({ getText: () => "string" }),
+        };
+        mockFuncDecl.getReturnType.mockReturnValue({
+            isObject: vi.fn().mockReturnValue(true),
+            getProperties: vi.fn().mockReturnValue([retProp]),
+            getSymbol: vi.fn().mockReturnValue(null),
+            getTypeArguments: vi.fn().mockReturnValue([]),
+        });
+        expect(() => compileAppActionSkills({})).toThrow('return property "missing" is missing');
+    });
+    it("should throw on duplicate action names", () => {
+        vi.mocked(globSync).mockReturnValue([
+            "src/skill/testAction/action.ts",
+            "src/skill/testAction/action.ts",
+        ]);
+        mockFuncDecl.getJsDocs.mockReturnValue([
+            {
+                getDescription: vi.fn().mockReturnValue("desc"),
+                getFullText: vi.fn().mockReturnValue("/** desc */"),
+            },
+        ]);
+        mockFuncDecl.getParameters.mockReturnValue([]);
+        mockFuncDecl.getReturnType.mockReturnValue({
+            isObject: vi.fn().mockReturnValue(true),
+            getProperties: vi.fn().mockReturnValue([]),
+            getSymbol: vi.fn().mockReturnValue(null),
+            getTypeArguments: vi.fn().mockReturnValue([]),
+        });
+        mockSourceFile.getDescendantsOfKind.mockReturnValue([]);
+        expect(() => compileAppActionSkills({})).toThrow('Duplicate action name');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pulse-editor/cli",
-	"version": "0.1.10",
+	"version": "0.1.11",
 	"license": "MIT",
 	"bin": {
 		"pulse": "dist/cli.js"
@@ -12,7 +12,8 @@
 	"scripts": {
 		"build": "tsx build.ts",
 		"dev": "tsx watch --include \"./src/**/*\" build.ts",
-		"test": "prettier --check . && xo && ava",
+		"test": "vitest run",
+		"test:coverage": "vitest run --coverage",
 		"link": "npm link",
 		"pack": "npm run build && npm pack --pack-destination dist"
 	},
@@ -58,6 +59,7 @@
 		"@types/livereload": "^0.9.5",
 		"@types/react": "^19.2.14",
 		"@types/react-dom": "^19.2.3",
+		"@vitest/coverage-v8": "^4.1.2",
 		"ava": "^6.4.1",
 		"chalk": "^5.6.2",
 		"eslint-config-xo-react": "^0.29.0",
@@ -68,6 +70,7 @@
 		"react-dom": "19.2.4",
 		"ts-node": "^10.9.2",
 		"typescript": "^5.9.3",
+		"vitest": "^4.1.2",
 		"xo": "^1.2.3"
 	},
 	"peerDependencies": {