@meshxdata/fops 0.0.1 → 0.0.4

package/src/plugins/api.test.js

@@ -1,95 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { createPluginApi } from "./api.js";
-import { createRegistry } from "./registry.js";
-
-describe("plugins/api", () => {
-  describe("createPluginApi", () => {
-    it("returns api with id and methods", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      expect(api.id).toBe("test-plugin");
-      expect(typeof api.registerCommand).toBe("function");
-      expect(typeof api.registerDoctorCheck).toBe("function");
-      expect(typeof api.registerHook).toBe("function");
-    });
-
-    it("has config property (empty by default)", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      expect(api.config).toEqual({});
-    });
-
-    it("registerCommand adds to registry.commands", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      const spec = { name: "my-cmd", description: "A command" };
-      api.registerCommand(spec);
-      expect(registry.commands).toHaveLength(1);
-      expect(registry.commands[0]).toEqual({ pluginId: "test-plugin", spec });
-    });
-
-    it("registerCommand can add multiple commands", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      api.registerCommand({ name: "cmd1" });
-      api.registerCommand({ name: "cmd2" });
-      api.registerCommand({ name: "cmd3" });
-      expect(registry.commands).toHaveLength(3);
-    });
-
-    it("registerDoctorCheck adds to registry.doctorChecks", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      const fn = vi.fn();
-      api.registerDoctorCheck({ name: "check-foo", fn });
-      expect(registry.doctorChecks).toHaveLength(1);
-      expect(registry.doctorChecks[0].name).toBe("check-foo");
-      expect(registry.doctorChecks[0].fn).toBe(fn);
-      expect(registry.doctorChecks[0].pluginId).toBe("test-plugin");
-    });
-
-    it("registerHook adds to registry.hooks with default priority", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      const handler = vi.fn();
-      api.registerHook("pre:up", handler);
-      expect(registry.hooks).toHaveLength(1);
-      expect(registry.hooks[0]).toEqual({
-        pluginId: "test-plugin",
-        event: "pre:up",
-        handler,
-        priority: 0,
-      });
-    });
-
-    it("registerHook respects custom priority", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      const handler = vi.fn();
-      api.registerHook("post:up", handler, 10);
-      expect(registry.hooks[0].priority).toBe(10);
-    });
-
-    it("multiple plugins can register on same registry", () => {
-      const registry = createRegistry();
-      const api1 = createPluginApi("plugin-a", registry);
-      const api2 = createPluginApi("plugin-b", registry);
-      api1.registerCommand({ name: "cmd-a" });
-      api2.registerCommand({ name: "cmd-b" });
-      api1.registerHook("pre:up", vi.fn());
-      api2.registerHook("pre:up", vi.fn());
-      expect(registry.commands).toHaveLength(2);
-      expect(registry.hooks).toHaveLength(2);
-      expect(registry.commands[0].pluginId).toBe("plugin-a");
-      expect(registry.commands[1].pluginId).toBe("plugin-b");
-    });
-
-    it("registerDoctorCheck preserves fn reference", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test", registry);
-      const checkFn = async (ok, warn, fail) => { ok("test passed"); };
-      api.registerDoctorCheck({ name: "my-check", fn: checkFn });
-      expect(registry.doctorChecks[0].fn).toBe(checkFn);
-    });
-  });
-});

package/src/plugins/discovery.test.js

@@ -1,92 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-describe("plugins/discovery", () => {
-  let tmpHome;
-
-  beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "fops-home-"));
-    vi.spyOn(os, "homedir").mockReturnValue(tmpHome);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-  });
-
-  it("returns empty when no plugin dirs exist", async () => {
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(0);
-  });
-
-  it("discovers global plugins with fops.plugin.json", async () => {
-    const pluginDir = path.join(tmpHome, ".fops", "plugins", "my-plugin");
-    fs.mkdirSync(pluginDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(pluginDir, "fops.plugin.json"),
-      JSON.stringify({ id: "my-plugin", name: "My Plugin", version: "1.0.0" })
-    );
-
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(1);
-    expect(globalPlugins[0].id).toBe("my-plugin");
-    expect(globalPlugins[0].path).toBe(pluginDir);
-    expect(globalPlugins[0].source).toBe("global");
-  });
-
-  it("skips global dirs without fops.plugin.json", async () => {
-    const pluginDir = path.join(tmpHome, ".fops", "plugins", "no-manifest");
-    fs.mkdirSync(pluginDir, { recursive: true });
-    fs.writeFileSync(path.join(pluginDir, "index.js"), "");
-
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(0);
-  });
-
-  it("discovers multiple global plugins", async () => {
-    for (const name of ["plugin-a", "plugin-b", "plugin-c"]) {
-      const dir = path.join(tmpHome, ".fops", "plugins", name);
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(
-        path.join(dir, "fops.plugin.json"),
-        JSON.stringify({ id: name, name, version: "1.0.0" })
-      );
-    }
-
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(3);
-  });
-
-  it("skips files (non-directories) in plugins dir", async () => {
-    const pluginsDir = path.join(tmpHome, ".fops", "plugins");
-    fs.mkdirSync(pluginsDir, { recursive: true });
-    fs.writeFileSync(path.join(pluginsDir, "not-a-dir.txt"), "");
-
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(0);
-  });
-
-  it("returns array even when ~/.fops/plugins does not exist", async () => {
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    expect(Array.isArray(result)).toBe(true);
-  });
-});

package/src/plugins/hooks.test.js

@@ -1,118 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { runHook } from "./hooks.js";
-
-describe("plugins/hooks", () => {
-  describe("runHook", () => {
-    it("runs matching handlers", async () => {
-      const handler = vi.fn();
-      const registry = {
-        hooks: [{ event: "pre:up", handler, priority: 0 }],
-      };
-      await runHook(registry, "pre:up", { root: "/project" });
-      expect(handler).toHaveBeenCalledWith({ root: "/project" });
-    });
-
-    it("skips non-matching events", async () => {
-      const handler = vi.fn();
-      const registry = {
-        hooks: [{ event: "pre:up", handler, priority: 0 }],
-      };
-      await runHook(registry, "post:up");
-      expect(handler).not.toHaveBeenCalled();
-    });
-
-    it("sorts by priority (higher first)", async () => {
-      const order = [];
-      const low = vi.fn(() => order.push("low"));
-      const high = vi.fn(() => order.push("high"));
-      const registry = {
-        hooks: [
-          { event: "pre:up", handler: low, priority: 1 },
-          { event: "pre:up", handler: high, priority: 10 },
-        ],
-      };
-      await runHook(registry, "pre:up");
-      expect(order).toEqual(["high", "low"]);
-    });
-
-    it("runs handlers sequentially (not parallel)", async () => {
-      const order = [];
-      const slow = vi.fn(async () => {
-        await new Promise((r) => setTimeout(r, 10));
-        order.push("slow");
-      });
-      const fast = vi.fn(() => order.push("fast"));
-      const registry = {
-        hooks: [
-          { event: "test", handler: slow, priority: 10 },
-          { event: "test", handler: fast, priority: 0 },
-        ],
-      };
-      await runHook(registry, "test");
-      expect(order).toEqual(["slow", "fast"]);
-    });
-
-    it("handles empty hooks array", async () => {
-      const registry = { hooks: [] };
-      await expect(runHook(registry, "pre:up")).resolves.toBeUndefined();
-    });
-
-    it("passes context to all handlers", async () => {
-      const h1 = vi.fn();
-      const h2 = vi.fn();
-      const ctx = { root: "/proj", extra: "data" };
-      const registry = {
-        hooks: [
-          { event: "test", handler: h1, priority: 0 },
-          { event: "test", handler: h2, priority: 0 },
-        ],
-      };
-      await runHook(registry, "test", ctx);
-      expect(h1).toHaveBeenCalledWith(ctx);
-      expect(h2).toHaveBeenCalledWith(ctx);
-    });
-
-    it("uses empty object as default context", async () => {
-      const handler = vi.fn();
-      const registry = {
-        hooks: [{ event: "test", handler, priority: 0 }],
-      };
-      await runHook(registry, "test");
-      expect(handler).toHaveBeenCalledWith({});
-    });
-
-    it("handles three priority levels correctly", async () => {
-      const order = [];
-      const registry = {
-        hooks: [
-          { event: "e", handler: () => order.push("med"), priority: 5 },
-          { event: "e", handler: () => order.push("low"), priority: 1 },
-          { event: "e", handler: () => order.push("high"), priority: 10 },
-        ],
-      };
-      await runHook(registry, "e");
-      expect(order).toEqual(["high", "med", "low"]);
-    });
-
-    it("only runs handlers for the exact event name", async () => {
-      const h1 = vi.fn();
-      const h2 = vi.fn();
-      const registry = {
-        hooks: [
-          { event: "pre:up", handler: h1, priority: 0 },
-          { event: "pre:down", handler: h2, priority: 0 },
-        ],
-      };
-      await runHook(registry, "pre:up");
-      expect(h1).toHaveBeenCalled();
-      expect(h2).not.toHaveBeenCalled();
-    });
-
-    it("handler errors propagate", async () => {
-      const registry = {
-        hooks: [{ event: "test", handler: () => { throw new Error("boom"); }, priority: 0 }],
-      };
-      await expect(runHook(registry, "test")).rejects.toThrow("boom");
-    });
-  });
-});

package/src/plugins/manifest.test.js

@@ -1,106 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { validateManifest } from "./manifest.js";
-
-describe("plugins/manifest", () => {
-  let tmpDir;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fops-manifest-"));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("returns null when no fops.plugin.json exists", () => {
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null for invalid JSON", () => {
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), "not json{{{");
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when id is missing", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ name: "Test", version: "1.0.0" })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when name is missing", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: "test", version: "1.0.0" })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when version is missing", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: "test", name: "Test" })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when fields are not strings", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: "test", name: "Test", version: 1 })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when id is empty string", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: "", name: "Test", version: "1.0.0" })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when fields are numbers", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: 1, name: 2, version: 3 })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns manifest when all required fields present", () => {
-    const manifest = { id: "test-plugin", name: "Test Plugin", version: "1.0.0" };
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), JSON.stringify(manifest));
-    const result = validateManifest(tmpDir);
-    expect(result).toEqual(manifest);
-  });
-
-  it("preserves extra fields in manifest", () => {
-    const manifest = {
-      id: "test-plugin",
-      name: "Test Plugin",
-      version: "1.0.0",
-      description: "A test",
-      author: "test",
-      skills: ["skills/foo"],
-    };
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), JSON.stringify(manifest));
-    const result = validateManifest(tmpDir);
-    expect(result.description).toBe("A test");
-    expect(result.skills).toEqual(["skills/foo"]);
-  });
-
-  it("returns null for empty JSON object", () => {
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), "{}");
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null for empty file", () => {
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), "");
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-});

package/src/plugins/registry.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createRegistry } from "./registry.js";
-
-describe("plugins/registry", () => {
-  describe("createRegistry", () => {
-    it("returns object with expected arrays", () => {
-      const reg = createRegistry();
-      expect(reg).toEqual({
-        plugins: [],
-        commands: [],
-        doctorChecks: [],
-        hooks: [],
-        skills: [],
-      });
-    });
-
-    it("creates independent instances", () => {
-      const a = createRegistry();
-      const b = createRegistry();
-      a.plugins.push({ id: "test" });
-      expect(b.plugins).toHaveLength(0);
-    });
-
-    it("all arrays are mutable", () => {
-      const reg = createRegistry();
-      reg.plugins.push({ id: "p1" });
-      reg.commands.push({ pluginId: "p1", spec: {} });
-      reg.doctorChecks.push({ pluginId: "p1", name: "check" });
-      reg.hooks.push({ pluginId: "p1", event: "test" });
-      reg.skills.push({ pluginId: "p1", name: "skill" });
-      expect(reg.plugins).toHaveLength(1);
-      expect(reg.commands).toHaveLength(1);
-      expect(reg.doctorChecks).toHaveLength(1);
-      expect(reg.hooks).toHaveLength(1);
-      expect(reg.skills).toHaveLength(1);
-    });
-
-    it("has exactly 5 keys", () => {
-      const reg = createRegistry();
-      expect(Object.keys(reg)).toHaveLength(5);
-    });
-  });
-});

package/src/plugins/skills.test.js

@@ -1,173 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-vi.mock("execa", () => ({
-  execa: vi.fn(() => Promise.resolve({ stdout: "" })),
-}));
-
-describe("plugins/skills", () => {
-  let tmpHome;
-
-  beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "fops-skills-"));
-    vi.spyOn(os, "homedir").mockReturnValue(tmpHome);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-  });
-
-  it("loads skills from ~/.fops/skills/", async () => {
-    const skillDir = path.join(tmpHome, ".fops", "skills", "my-skill");
-    fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(skillDir, "SKILL.md"),
-      `---\nname: My Skill\ndescription: A test skill\n---\nThis is the skill content.`
-    );
-
-    vi.resetModules();
-    vi.mock("execa", () => ({
-      execa: vi.fn(() => Promise.resolve({ stdout: "" })),
-    }));
-    const { loadSkills } = await import("./skills.js");
-    const skills = await loadSkills();
-    const userSkills = skills.filter((s) => s.name === "My Skill");
-    expect(userSkills).toHaveLength(1);
-    expect(userSkills[0].description).toBe("A test skill");
-    expect(userSkills[0].content).toBe("This is the skill content.");
-    expect(userSkills[0].pluginId).toBe(null);
-  });
-
-  it("parses frontmatter correctly", async () => {
-    const skillDir = path.join(tmpHome, ".fops", "skills", "fm-test");
-    fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(skillDir, "SKILL.md"),
-      `---\nname: FM Test\ndescription: Frontmatter test\n---\nBody text here.`
-    );
-
-    vi.resetModules();
-    vi.mock("execa", () => ({
-      execa: vi.fn(() => Promise.resolve({ stdout: "" })),
-    }));
-    const { loadSkills } = await import("./skills.js");
-    const skills = await loadSkills();
-    const skill = skills.find((s) => s.name === "FM Test");
-    expect(skill).toBeDefined();
-    expect(skill.content).toBe("Body text here.");
-  });
-
-  it("uses dir name as fallback name", async () => {
-    const skillDir = path.join(tmpHome, ".fops", "skills", "unnamed-skill");
-    fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(path.join(skillDir, "SKILL.md"), "Just a body, no frontmatter.");
-
-    vi.resetModules();
-    vi.mock("execa", () => ({
-      execa: vi.fn(() => Promise.resolve({ stdout: "" })),
-    }));
-    const { loadSkills } = await import("./skills.js");
-    const skills = await loadSkills();
-    const skill = skills.find((s) => s.name === "unnamed-skill");
-    expect(skill).toBeDefined();
-    expect(skill.content).toBe("Just a body, no frontmatter.");
-  });
-
-  it("includes skills from registry", async () => {
-    vi.resetModules();
-    vi.mock("execa", () => ({
-      execa: vi.fn(() => Promise.resolve({ stdout: "" })),
-    }));
-    const { loadSkills } = await import("./skills.js");
-    const registry = {
-      skills: [{ pluginId: "p1", name: "Plugin Skill", description: "From plugin", content: "plugin content" }],
-    };
-    const skills = await loadSkills(registry);
-    const pluginSkill = skills.find((s) => s.name === "Plugin Skill");
-    expect(pluginSkill).toBeDefined();
-    expect(pluginSkill.content).toBe("plugin content");
-  });
-
-  it("returns empty when no skills directories exist", async () => {
-    vi.resetModules();
-    vi.mock("execa", () => ({
-      execa: vi.fn(() => Promise.resolve({ stdout: "" })),
-    }));
-    const { loadSkills } = await import("./skills.js");
-    const skills = await loadSkills();
-    // May include built-in skills from src/skills, but no user skills
-    const userSkills = skills.filter((s) => s.pluginId === null);
-    // All returned skills should have correct shape
-    for (const s of skills) {
-      expect(typeof s.name).toBe("string");
-      expect(typeof s.content).toBe("string");
-    }
-  });
-
-  it("returns empty when null registry is passed", async () => {
-    vi.resetModules();
-    vi.mock("execa", () => ({
-      execa: vi.fn(() => Promise.resolve({ stdout: "" })),
-    }));
-    const { loadSkills } = await import("./skills.js");
-    const skills = await loadSkills(null);
-    expect(Array.isArray(skills)).toBe(true);
-  });
-
-  it("skips dirs without SKILL.md", async () => {
-    const skillDir = path.join(tmpHome, ".fops", "skills", "no-skill-md");
-    fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(path.join(skillDir, "README.md"), "Not a skill");
-
-    vi.resetModules();
-    vi.mock("execa", () => ({
-      execa: vi.fn(() => Promise.resolve({ stdout: "" })),
-    }));
-    const { loadSkills } = await import("./skills.js");
-    const skills = await loadSkills();
-    const match = skills.find((s) => s.name === "no-skill-md");
-    expect(match).toBeUndefined();
-  });
-
-  it("loads multiple skills from ~/.fops/skills/", async () => {
-    for (const name of ["skill-a", "skill-b"]) {
-      const dir = path.join(tmpHome, ".fops", "skills", name);
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(
-        path.join(dir, "SKILL.md"),
-        `---\nname: ${name}\ndescription: desc\n---\nContent for ${name}.`
-      );
-    }
-
-    vi.resetModules();
-    vi.mock("execa", () => ({
-      execa: vi.fn(() => Promise.resolve({ stdout: "" })),
-    }));
-    const { loadSkills } = await import("./skills.js");
-    const skills = await loadSkills();
-    expect(skills.find((s) => s.name === "skill-a")).toBeDefined();
-    expect(skills.find((s) => s.name === "skill-b")).toBeDefined();
-  });
-
-  it("handles multi-line frontmatter values", async () => {
-    const skillDir = path.join(tmpHome, ".fops", "skills", "multi-fm");
-    fs.mkdirSync(skillDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(skillDir, "SKILL.md"),
-      `---\nname: Multi\ndescription: Has multiple fields\nrequires: nonexistent-binary\n---\nBody.`
-    );
-
-    vi.resetModules();
-    vi.mock("execa", () => ({
-      execa: vi.fn(() => { throw new Error("not found"); }),
-    }));
-    const { loadSkills } = await import("./skills.js");
-    const skills = await loadSkills();
-    // Should be filtered out due to requires gate
-    const match = skills.find((s) => s.name === "Multi");
-    expect(match).toBeUndefined();
-  });
-});