@uluops/setup 0.2.0 → 0.6.0

package/dist/test/auth.test.d.ts

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

package/dist/test/auth.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import { resolveApiKey } from "../steps/auth.js";
-afterEach(() => {
-    vi.unstubAllEnvs();
-});
-describe("resolveApiKey", () => {
-    it("uses --api-key flag when provided", async () => {
-        const result = await resolveApiKey({
-            apiKeyFlag: "ulr_test123",
-            skipValidation: true,
-        });
-        expect(result.apiKey).toBe("ulr_test123");
-        expect(result.email).toBeNull();
-    });
-    it("uses ULUOPS_API_KEY env var when no flag", async () => {
-        vi.stubEnv("ULUOPS_API_KEY", "ulr_envkey");
-        const result = await resolveApiKey({
-            skipValidation: true,
-        });
-        expect(result.apiKey).toBe("ulr_envkey");
-    });
-    it("throws when key does not start with ulr_", async () => {
-        await expect(resolveApiKey({
-            apiKeyFlag: "bad_key",
-            skipValidation: true,
-        })).rejects.toThrow("API keys start with ulr_");
-    });
-    it("throws when no key found and not interactive", async () => {
-        vi.stubEnv("ULUOPS_API_KEY", "");
-        await expect(resolveApiKey({
-            interactive: false,
-            skipValidation: true,
-        })).rejects.toThrow("No API key found");
-    });
-    it("flag takes priority over env var", async () => {
-        vi.stubEnv("ULUOPS_API_KEY", "ulr_envkey");
-        const result = await resolveApiKey({
-            apiKeyFlag: "ulr_flagkey",
-            skipValidation: true,
-        });
-        expect(result.apiKey).toBe("ulr_flagkey");
-    });
-});

package/dist/test/config-io.test.d.ts

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

package/dist/test/config-io.test.js

@@ -1,56 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { writeFile, unlink, mkdtemp, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { readConfig, writeConfig } from "../lib/config-merger.js";
-let tmpDir;
-beforeEach(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), "uluops-config-io-"));
-});
-afterEach(async () => {
-    try {
-        const { readdir } = await import("node:fs/promises");
-        for (const f of await readdir(tmpDir)) {
-            await unlink(join(tmpDir, f));
-        }
-    }
-    catch {
-        // cleanup best-effort
-    }
-});
-describe("readConfig", () => {
-    it("returns empty object when file does not exist", async () => {
-        const result = await readConfig(join(tmpDir, "nonexistent.json"));
-        expect(result).toEqual({});
-    });
-    it("returns empty object on malformed JSON", async () => {
-        const path = join(tmpDir, "bad.json");
-        await writeFile(path, "{ invalid }");
-        const result = await readConfig(path);
-        expect(result).toEqual({});
-    });
-    it("parses valid JSON correctly", async () => {
-        const path = join(tmpDir, "good.json");
-        await writeFile(path, JSON.stringify({ mcpServers: {}, numStartups: 5 }));
-        const result = await readConfig(path);
-        expect(result.mcpServers).toEqual({});
-        expect(result.numStartups).toBe(5);
-    });
-});
-describe("writeConfig", () => {
-    it("writes formatted JSON with trailing newline", async () => {
-        const path = join(tmpDir, "output.json");
-        await writeConfig(path, { mcpServers: {}, foo: "bar" });
-        const raw = await readFile(path, "utf-8");
-        expect(raw).toMatch(/\n$/);
-        const parsed = JSON.parse(raw);
-        expect(parsed.foo).toBe("bar");
-    });
-    it("round-trips through readConfig", async () => {
-        const path = join(tmpDir, "roundtrip.json");
-        const config = { mcpServers: { test: { command: "echo", args: [], env: {} } }, extra: true };
-        await writeConfig(path, config);
-        const loaded = await readConfig(path);
-        expect(loaded).toEqual(config);
-    });
-});

package/dist/test/config-merger.test.d.ts

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

package/dist/test/config-merger.test.js

@@ -1,94 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { mergeUluopsMcp, removeUluopsMcp } from "../lib/config-merger.js";
-describe("mergeUluopsMcp", () => {
-    it("adds both MCP servers to empty config", () => {
-        const result = mergeUluopsMcp({}, "ulr_test123");
-        expect(result.mcpServers).toBeDefined();
-        expect(result.mcpServers["uluops-tracker"]).toMatchObject({
-            command: "npx",
-            args: ["-y", "uluops-tracker-mcp-client"],
-            env: {
-                ULUOPS_TRACKER_API_URL: "https://api.uluops.ai/api/v1",
-                ULUOPS_TRACKER_API_KEY: "ulr_test123",
-            },
-        });
-        expect(result.mcpServers["uluops-registry"]).toMatchObject({
-            command: "npx",
-            args: ["-y", "uluops-registry-mcp-client"],
-            env: {
-                ULUOPS_REGISTRY_URL: "https://api.uluops.ai/api/v1/registry",
-                ULUOPS_API_KEY: "ulr_test123",
-            },
-        });
-    });
-    it("preserves existing non-UluOps MCP servers", () => {
-        const config = {
-            mcpServers: {
-                "other-server": { command: "node", args: ["./other.js"], env: {} },
-            },
-        };
-        const result = mergeUluopsMcp(config, "ulr_abc");
-        expect(result.mcpServers["other-server"]).toBeDefined();
-        expect(result.mcpServers["uluops-tracker"]).toBeDefined();
-    });
-    it("preserves all top-level non-mcpServers keys", () => {
-        const config = {
-            numStartups: 42,
-            tipsHistory: ["tip1"],
-            mcpServers: {},
-        };
-        const result = mergeUluopsMcp(config, "ulr_abc");
-        expect(result.numStartups).toBe(42);
-        expect(result.tipsHistory).toEqual(["tip1"]);
-    });
-    it("overwrites existing UluOps servers with new API key", () => {
-        const config = {
-            mcpServers: {
-                "uluops-registry": {
-                    command: "npx",
-                    args: ["-y", "uluops-registry-mcp-client"],
-                    env: { ULUOPS_API_KEY: "ulr_old", ULUOPS_REGISTRY_URL: "https://api.uluops.ai/api/v1/registry" },
-                },
-            },
-        };
-        const result = mergeUluopsMcp(config, "ulr_new");
-        expect(result.mcpServers["uluops-registry"].env["ULUOPS_API_KEY"]).toBe("ulr_new");
-    });
-});
-describe("removeUluopsMcp", () => {
-    it("removes both UluOps servers", () => {
-        const config = {
-            mcpServers: {
-                "uluops-tracker": { command: "npx", args: [], env: {} },
-                "uluops-registry": { command: "npx", args: [], env: {} },
-            },
-        };
-        const result = removeUluopsMcp(config);
-        expect(result.mcpServers).toBeUndefined();
-    });
-    it("preserves non-UluOps servers when removing", () => {
-        const config = {
-            mcpServers: {
-                "uluops-tracker": { command: "npx", args: [], env: {} },
-                "other-server": { command: "node", args: [], env: {} },
-            },
-        };
-        const result = removeUluopsMcp(config);
-        expect(result.mcpServers["other-server"]).toBeDefined();
-        expect(result.mcpServers["uluops-tracker"]).toBeUndefined();
-    });
-    it("preserves top-level keys other than mcpServers", () => {
-        const config = {
-            numStartups: 5,
-            mcpServers: {
-                "uluops-tracker": { command: "npx", args: [], env: {} },
-            },
-        };
-        const result = removeUluopsMcp(config);
-        expect(result.numStartups).toBe(5);
-    });
-    it("handles config with no mcpServers key", () => {
-        const result = removeUluopsMcp({ numStartups: 1 });
-        expect(result.mcpServers).toBeUndefined();
-    });
-});

package/dist/test/detect.test.d.ts

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

package/dist/test/detect.test.js

@@ -1,25 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { detect } from "../steps/detect.js";
-describe("detect", () => {
-    it("returns a valid Environment object", async () => {
-        const env = await detect();
-        expect(env).toHaveProperty("os");
-        expect(env).toHaveProperty("isWsl");
-        expect(env).toHaveProperty("shell");
-        expect(env).toHaveProperty("shellProfile");
-        expect(env).toHaveProperty("nodeVersion");
-        expect(env).toHaveProperty("claudeHomeExists");
-    });
-    it("nodeVersion matches process.version", async () => {
-        const env = await detect();
-        expect(env.nodeVersion).toBe(process.version);
-    });
-    it("os is one of the supported platforms", async () => {
-        const env = await detect();
-        expect(["linux", "darwin", "win32"]).toContain(env.os);
-    });
-    it("claudeHomeExists is a boolean", async () => {
-        const env = await detect();
-        expect(typeof env.claudeHomeExists).toBe("boolean");
-    });
-});

package/dist/test/file-ops.test.d.ts

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

package/dist/test/file-ops.test.js

@@ -1,100 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { writeFile, readFile, mkdir, mkdtemp, readdir } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { copyIfChanged, unlinkFiles, syncAssets } from "../lib/file-ops.js";
-let tmpDir;
-let srcDir;
-let destDir;
-beforeEach(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), "uluops-fileops-"));
-    srcDir = join(tmpDir, "src");
-    destDir = join(tmpDir, "dest");
-    await mkdir(srcDir, { recursive: true });
-    await mkdir(destDir, { recursive: true });
-});
-describe("copyIfChanged", () => {
-    it("copies file when destination does not exist", async () => {
-        await writeFile(join(srcDir, "a.md"), "content A");
-        const result = await copyIfChanged(join(srcDir, "a.md"), join(destDir, "a.md"), false);
-        expect(result).toBe("copied");
-        expect(await readFile(join(destDir, "a.md"), "utf-8")).toBe("content A");
-    });
-    it("skips file when content is identical", async () => {
-        await writeFile(join(srcDir, "a.md"), "same");
-        await writeFile(join(destDir, "a.md"), "same");
-        const result = await copyIfChanged(join(srcDir, "a.md"), join(destDir, "a.md"), false);
-        expect(result).toBe("skipped");
-    });
-    it("copies file when content differs", async () => {
-        await writeFile(join(srcDir, "a.md"), "new content");
-        await writeFile(join(destDir, "a.md"), "old content");
-        const result = await copyIfChanged(join(srcDir, "a.md"), join(destDir, "a.md"), false);
-        expect(result).toBe("copied");
-        expect(await readFile(join(destDir, "a.md"), "utf-8")).toBe("new content");
-    });
-    it("does not write in dry-run mode", async () => {
-        await writeFile(join(srcDir, "a.md"), "content");
-        const result = await copyIfChanged(join(srcDir, "a.md"), join(destDir, "a.md"), true);
-        expect(result).toBe("copied");
-        // File should NOT exist
-        const files = await readdir(destDir);
-        expect(files).not.toContain("a.md");
-    });
-});
-describe("unlinkFiles", () => {
-    it("removes listed files and returns count", async () => {
-        await writeFile(join(destDir, "a.md"), "a");
-        await writeFile(join(destDir, "b.md"), "b");
-        const removed = await unlinkFiles(destDir, ["a.md", "b.md"]);
-        expect(removed).toBe(2);
-        expect(await readdir(destDir)).toEqual([]);
-    });
-    it("returns 0 for already-missing files", async () => {
-        const removed = await unlinkFiles(destDir, ["nonexistent.md"]);
-        expect(removed).toBe(0);
-    });
-});
-describe("syncAssets", () => {
-    it("copies all .md files from source to destination", async () => {
-        await writeFile(join(srcDir, "one.md"), "one");
-        await writeFile(join(srcDir, "two.md"), "two");
-        await writeFile(join(srcDir, "skip.txt"), "not md");
-        const result = await syncAssets({ srcDir, destDir, dryRun: false });
-        expect(result.copied).toBe(2);
-        expect(result.files).toContain("one.md");
-        expect(result.files).toContain("two.md");
-        expect(result.files).not.toContain("skip.txt");
-    });
-    it("skips unchanged files on second run", async () => {
-        await writeFile(join(srcDir, "one.md"), "content");
-        await syncAssets({ srcDir, destDir, dryRun: false });
-        const result = await syncAssets({ srcDir, destDir, dryRun: false });
-        expect(result.copied).toBe(0);
-        expect(result.skipped).toBe(1);
-    });
-    it("removes old manifest files no longer in source", async () => {
-        await writeFile(join(srcDir, "keep.md"), "keep");
-        await writeFile(join(destDir, "removed.md"), "old");
-        const result = await syncAssets({
-            srcDir,
-            destDir,
-            dryRun: false,
-            oldManifestFiles: ["keep.md", "removed.md"],
-        });
-        expect(result.removed).toBe(1);
-        expect(await readdir(destDir)).toContain("keep.md");
-        expect(await readdir(destDir)).not.toContain("removed.md");
-    });
-    it("creates destination directory if missing", async () => {
-        const newDest = join(tmpDir, "newdir");
-        await writeFile(join(srcDir, "a.md"), "a");
-        const result = await syncAssets({
-            srcDir,
-            destDir: newDest,
-            dryRun: false,
-        });
-        expect(result.copied).toBe(1);
-        expect(await readdir(newDest)).toContain("a.md");
-    });
-});

package/dist/test/hash.test.d.ts

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

package/dist/test/hash.test.js

@@ -1,14 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { fileHash } from "../lib/hash.js";
-describe("fileHash", () => {
-    it("returns a 12-character hex string", () => {
-        const hash = fileHash("hello world");
-        expect(hash).toMatch(/^[0-9a-f]{12}$/);
-    });
-    it("returns same hash for same content", () => {
-        expect(fileHash("test")).toBe(fileHash("test"));
-    });
-    it("returns different hash for different content", () => {
-        expect(fileHash("a")).not.toBe(fileHash("b"));
-    });
-});

package/dist/test/manifest.test.d.ts

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

package/dist/test/manifest.test.js

@@ -1,78 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { writeFile, unlink, mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-// We need to control the manifest path, so we mock paths.js
-const tmpDir = join(tmpdir(), "uluops-manifest-test-" + Date.now());
-const manifestPath = join(tmpDir, "uluops-manifest.json");
-vi.mock("../lib/paths.js", async (importOriginal) => {
-    const original = await importOriginal();
-    return {
-        ...original,
-        getManifestPath: () => manifestPath,
-    };
-});
-// Import after mock is set up
-const { loadManifest, saveManifest, deleteManifest } = await import("../lib/manifest.js");
-const sampleManifest = {
-    version: "0.1.0",
-    installedAt: "2026-03-08T00:00:00.000Z",
-    mcpScope: "global",
-    mcpConfigPath: "/home/user/.claude.json",
-    defsScope: "global",
-    defsPath: "/home/user/.claude",
-    shellModified: false,
-    agents: ["code-validator-agent.md"],
-    commands: ["agents/validate.md"],
-};
-beforeEach(async () => {
-    await mkdir(tmpDir, { recursive: true });
-});
-afterEach(async () => {
-    try {
-        await unlink(manifestPath);
-    }
-    catch {
-        // may not exist
-    }
-});
-describe("loadManifest", () => {
-    it("returns null when manifest does not exist", async () => {
-        const result = await loadManifest();
-        expect(result).toBeNull();
-    });
-    it("returns parsed manifest when file exists", async () => {
-        await writeFile(manifestPath, JSON.stringify(sampleManifest, null, 2));
-        const result = await loadManifest();
-        expect(result).toEqual(sampleManifest);
-    });
-    it("returns null on malformed JSON", async () => {
-        await writeFile(manifestPath, "{ invalid json }");
-        const result = await loadManifest();
-        expect(result).toBeNull();
-    });
-});
-describe("saveManifest", () => {
-    it("writes manifest as formatted JSON", async () => {
-        await saveManifest(sampleManifest);
-        const raw = await import("node:fs/promises").then((fs) => fs.readFile(manifestPath, "utf-8"));
-        const parsed = JSON.parse(raw);
-        expect(parsed).toEqual(sampleManifest);
-    });
-    it("round-trips correctly through save and load", async () => {
-        await saveManifest(sampleManifest);
-        const loaded = await loadManifest();
-        expect(loaded).toEqual(sampleManifest);
-    });
-});
-describe("deleteManifest", () => {
-    it("deletes existing manifest", async () => {
-        await writeFile(manifestPath, JSON.stringify(sampleManifest));
-        await deleteManifest();
-        const result = await loadManifest();
-        expect(result).toBeNull();
-    });
-    it("does not throw if manifest does not exist", async () => {
-        await expect(deleteManifest()).resolves.toBeUndefined();
-    });
-});

package/dist/test/paths.test.d.ts

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

package/dist/test/paths.test.js

@@ -1,30 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { getClaudeHome, getClaudeJsonPath, getLocalMcpPath, getManifestPath, getAgentsDir, getCommandsDir, } from "../lib/paths.js";
-describe("path resolution", () => {
-    it("getClaudeHome returns ~/.claude", () => {
-        expect(getClaudeHome()).toBe(join(homedir(), ".claude"));
-    });
-    it("getClaudeJsonPath returns ~/.claude.json", () => {
-        expect(getClaudeJsonPath()).toBe(join(homedir(), ".claude.json"));
-    });
-    it("getLocalMcpPath returns .mcp.json in cwd", () => {
-        expect(getLocalMcpPath()).toBe(join(process.cwd(), ".mcp.json"));
-    });
-    it("getManifestPath returns ~/.claude/uluops-manifest.json", () => {
-        expect(getManifestPath()).toBe(join(homedir(), ".claude", "uluops-manifest.json"));
-    });
-    it("getAgentsDir returns ~/.claude/agents when not local", () => {
-        expect(getAgentsDir(false)).toBe(join(homedir(), ".claude", "agents"));
-    });
-    it("getAgentsDir returns ./uluops/agents when local", () => {
-        expect(getAgentsDir(true)).toBe(join(process.cwd(), "uluops", "agents"));
-    });
-    it("getCommandsDir returns ~/.claude/commands when not local", () => {
-        expect(getCommandsDir(false)).toBe(join(homedir(), ".claude", "commands"));
-    });
-    it("getCommandsDir returns ./uluops/commands when local", () => {
-        expect(getCommandsDir(true)).toBe(join(process.cwd(), "uluops", "commands"));
-    });
-});

package/dist/test/settings-merger.test.d.ts

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

package/dist/test/settings-merger.test.js

@@ -1,167 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { mergeUluopsHook, removeUluopsHook, hasUluopsHook, } from "../lib/settings-merger.js";
-describe("settings-merger", () => {
-    describe("mergeUluopsHook", () => {
-        it("should add hook to empty settings", () => {
-            const result = mergeUluopsHook({}, "node ~/.claude/tools/agent-metrics/dist/hook.js");
-            expect(result.hooks).toBeDefined();
-            expect(result.hooks["SubagentStop"]).toHaveLength(1);
-            expect(result.hooks["SubagentStop"][0].hooks[0].command).toContain("tools/agent-metrics");
-            expect(result.hooks["SubagentStop"][0].hooks[0].timeout).toBe(30);
-        });
-        it("should preserve existing permissions", () => {
-            const settings = {
-                permissions: { allow: ["Bash(curl:*)"] },
-            };
-            const result = mergeUluopsHook(settings, "node ~/.claude/tools/agent-metrics/dist/hook.js");
-            expect(result.permissions).toEqual({ allow: ["Bash(curl:*)"] });
-            expect(result.hooks["SubagentStop"]).toHaveLength(1);
-        });
-        it("should preserve non-UluOps hooks", () => {
-            const settings = {
-                hooks: {
-                    SubagentStop: [
-                        {
-                            hooks: [
-                                { type: "command", command: "echo custom-hook" },
-                            ],
-                        },
-                    ],
-                },
-            };
-            const result = mergeUluopsHook(settings, "node ~/.claude/tools/agent-metrics/dist/hook.js");
-            // Should have both: custom + UluOps
-            expect(result.hooks["SubagentStop"]).toHaveLength(2);
-            expect(result.hooks["SubagentStop"][0].hooks[0].command).toBe("echo custom-hook");
-            expect(result.hooks["SubagentStop"][1].hooks[0].command).toContain("tools/agent-metrics");
-        });
-        it("should replace existing UluOps hook on re-run", () => {
-            const settings = {
-                hooks: {
-                    SubagentStop: [
-                        {
-                            hooks: [
-                                {
-                                    type: "command",
-                                    command: "node /old/path/tools/agent-metrics/dist/hook.js",
-                                },
-                            ],
-                        },
-                    ],
-                },
-            };
-            const result = mergeUluopsHook(settings, "node ~/.claude/tools/agent-metrics/dist/hook.js");
-            // Should replace, not duplicate
-            expect(result.hooks["SubagentStop"]).toHaveLength(1);
-            expect(result.hooks["SubagentStop"][0].hooks[0].command).toContain("~/.claude/tools/agent-metrics");
-        });
-        it("should preserve other hook event types", () => {
-            const settings = {
-                hooks: {
-                    PreToolUse: [{ hooks: [{ type: "command", command: "echo pre" }] }],
-                },
-            };
-            const result = mergeUluopsHook(settings, "node ~/.claude/tools/agent-metrics/dist/hook.js");
-            expect(result.hooks["PreToolUse"]).toHaveLength(1);
-            expect(result.hooks["SubagentStop"]).toHaveLength(1);
-        });
-    });
-    describe("removeUluopsHook", () => {
-        it("should remove UluOps hook and preserve permissions", () => {
-            const settings = {
-                permissions: { allow: ["Bash(curl:*)"] },
-                hooks: {
-                    SubagentStop: [
-                        {
-                            hooks: [
-                                {
-                                    type: "command",
-                                    command: "node ~/.claude/tools/agent-metrics/dist/hook.js",
-                                    timeout: 30,
-                                },
-                            ],
-                        },
-                    ],
-                },
-            };
-            const result = removeUluopsHook(settings);
-            expect(result.permissions).toEqual({ allow: ["Bash(curl:*)"] });
-            expect(result.hooks).toBeUndefined();
-        });
-        it("should preserve non-UluOps hooks", () => {
-            const settings = {
-                hooks: {
-                    SubagentStop: [
-                        { hooks: [{ type: "command", command: "echo custom" }] },
-                        {
-                            hooks: [
-                                {
-                                    type: "command",
-                                    command: "node ~/.claude/tools/agent-metrics/dist/hook.js",
-                                },
-                            ],
-                        },
-                    ],
-                },
-            };
-            const result = removeUluopsHook(settings);
-            expect(result.hooks["SubagentStop"]).toHaveLength(1);
-            expect(result.hooks["SubagentStop"][0].hooks[0].command).toBe("echo custom");
-        });
-        it("should handle settings with no hooks", () => {
-            const settings = { permissions: { allow: [] } };
-            const result = removeUluopsHook(settings);
-            expect(result).toEqual({ permissions: { allow: [] } });
-        });
-        it("should clean up empty hooks object", () => {
-            const settings = {
-                hooks: {
-                    SubagentStop: [
-                        {
-                            hooks: [
-                                {
-                                    type: "command",
-                                    command: "node /some/tools/agent-metrics/hook.js",
-                                },
-                            ],
-                        },
-                    ],
-                },
-            };
-            const result = removeUluopsHook(settings);
-            expect(result.hooks).toBeUndefined();
-        });
-    });
-    describe("hasUluopsHook", () => {
-        it("should return true when UluOps hook is present", () => {
-            const settings = {
-                hooks: {
-                    SubagentStop: [
-                        {
-                            hooks: [
-                                {
-                                    type: "command",
-                                    command: "node ~/.claude/tools/agent-metrics/dist/hook.js",
-                                },
-                            ],
-                        },
-                    ],
-                },
-            };
-            expect(hasUluopsHook(settings)).toBe(true);
-        });
-        it("should return false when no hooks exist", () => {
-            expect(hasUluopsHook({})).toBe(false);
-        });
-        it("should return false when only non-UluOps hooks exist", () => {
-            const settings = {
-                hooks: {
-                    SubagentStop: [
-                        { hooks: [{ type: "command", command: "echo custom" }] },
-                    ],
-                },
-            };
-            expect(hasUluopsHook(settings)).toBe(false);
-        });
-    });
-});

package/dist/test/shell-profile.test.d.ts

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