@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/cli/lib/__tests__/publish-plugin.test.ts

@@ -0,0 +1,404 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "bun:test";
+
+import {
+  buildPublishPayload,
+  findPluginRoot,
+  formatPayloadForPrint,
+  formatPublishResult,
+  formatValidationResult,
+  type ParsedPackageJson,
+  type PublishValidation,
+  runPublish,
+  validatePluginForPublish,
+} from "../publish-plugin.js";
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+function makePluginDir(
+  base: string,
+  pkg: Partial<ParsedPackageJson> = {},
+  surfaces: { hooks?: boolean; tools?: boolean; skills?: boolean } = {},
+): string {
+  const dir = mkdtempSync(join(base, "plugin-"));
+  writeFileSync(
+    join(dir, "package.json"),
+    JSON.stringify({
+      name: "test-plugin",
+      version: "1.0.0",
+      description: "A test plugin",
+      license: "MIT",
+      homepage: "https://github.com/test/test-plugin",
+      peerDependencies: { "@vellumai/plugin-api": "^1.0.0" },
+      ...pkg,
+    }),
+  );
+  if (surfaces.hooks) {
+    mkdirSync(join(dir, "hooks"));
+    writeFileSync(join(dir, "hooks", "post-tool-use.ts"), "// hook");
+  }
+  if (surfaces.tools) {
+    mkdirSync(join(dir, "tools"));
+    writeFileSync(join(dir, "tools", "my-tool.ts"), "// tool");
+  }
+  if (surfaces.skills) {
+    mkdirSync(join(dir, "skills"));
+    writeFileSync(join(dir, "skills", "my-skill"), "content");
+  }
+  return dir;
+}
+
+const validPkg: Partial<ParsedPackageJson> = {
+  name: "test-plugin",
+  version: "1.0.0",
+  peerDependencies: { "@vellumai/plugin-api": "^1.0.0" },
+  description: "A test plugin",
+  license: "MIT",
+  homepage: "https://github.com/test/test-plugin",
+};
+
+// ---------------------------------------------------------------------------
+// findPluginRoot
+// ---------------------------------------------------------------------------
+
+describe("findPluginRoot", () => {
+  it("finds package.json in the given directory", () => {
+    const dir = makePluginDir(tmpdir());
+    expect(findPluginRoot(dir)).toBe(dir);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("finds package.json in a parent directory", () => {
+    const dir = makePluginDir(tmpdir());
+    const subDir = join(dir, "subdir");
+    mkdirSync(subDir);
+    expect(findPluginRoot(subDir)).toBe(dir);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns null when no package.json exists", () => {
+    const dir = mkdtempSync(join(tmpdir(), "empty-"));
+    expect(findPluginRoot(dir)).toBeNull();
+    rmSync(dir, { recursive: true });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// validatePluginForPublish
+// ---------------------------------------------------------------------------
+
+describe("validatePluginForPublish", () => {
+  it("passes for a valid plugin with surfaces", () => {
+    const dir = makePluginDir(tmpdir(), validPkg, { hooks: true });
+    const result = validatePluginForPublish(dir);
+    expect(result.valid).toBe(true);
+    expect(result.issues).toHaveLength(0);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("fails when package.json is missing", () => {
+    const dir = mkdtempSync(join(tmpdir(), "no-pkg-"));
+    const result = validatePluginForPublish(dir);
+    expect(result.valid).toBe(false);
+    expect(result.issues).toContain("package.json not found");
+    rmSync(dir, { recursive: true });
+  });
+
+  it("fails when name is missing", () => {
+    const dir = makePluginDir(tmpdir(), {
+      ...validPkg,
+      name: undefined,
+    });
+    const result = validatePluginForPublish(dir);
+    expect(result.valid).toBe(false);
+    expect(result.issues.some((i) => i.includes("missing 'name'"))).toBe(true);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("fails when name is not kebab-case", () => {
+    const dir = makePluginDir(tmpdir(), {
+      ...validPkg,
+      name: "NotKebabCase",
+    });
+    const result = validatePluginForPublish(dir);
+    expect(result.valid).toBe(false);
+    expect(result.issues.some((i) => i.includes("kebab-case"))).toBe(true);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("fails when version is missing", () => {
+    const dir = makePluginDir(tmpdir(), {
+      ...validPkg,
+      version: undefined,
+    });
+    const result = validatePluginForPublish(dir);
+    expect(result.valid).toBe(false);
+    expect(result.issues.some((i) => i.includes("missing 'version'"))).toBe(
+      true,
+    );
+    rmSync(dir, { recursive: true });
+  });
+
+  it("fails when @vellumai/plugin-api peer dep is missing", () => {
+    const dir = makePluginDir(tmpdir(), {
+      ...validPkg,
+      peerDependencies: {},
+    });
+    const result = validatePluginForPublish(dir);
+    expect(result.valid).toBe(false);
+    expect(result.issues.some((i) => i.includes("@vellumai/plugin-api"))).toBe(
+      true,
+    );
+    rmSync(dir, { recursive: true });
+  });
+
+  it("warns when no surface directories have entries", () => {
+    const dir = makePluginDir(tmpdir(), validPkg);
+    const result = validatePluginForPublish(dir);
+    expect(result.valid).toBe(true);
+    expect(result.warnings.length).toBeGreaterThan(0);
+    expect(result.warnings.some((w) => w.includes("No hooks/"))).toBe(true);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("warns about stale .js without matching .ts", () => {
+    const dir = makePluginDir(tmpdir(), validPkg, { hooks: true });
+    // Add a stale .js file without a matching .ts
+    writeFileSync(join(dir, "hooks", "orphan.js"), "// stale");
+    const result = validatePluginForPublish(dir);
+    expect(result.valid).toBe(true);
+    expect(result.warnings.some((w) => w.includes("orphan.js"))).toBe(true);
+    rmSync(dir, { recursive: true });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildPublishPayload
+// ---------------------------------------------------------------------------
+
+describe("buildPublishPayload", () => {
+  it("assembles payload from validation and git context", () => {
+    const validation: PublishValidation = {
+      valid: true,
+      issues: [],
+      warnings: [],
+      packageJson: {
+        name: "my-plugin",
+        version: "1.0.0",
+        description: "Does cool stuff",
+        license: "MIT",
+        homepage: "https://github.com/me/my-plugin",
+        peerDependencies: { "@vellumai/plugin-api": "^1.0.0" },
+      },
+      pluginDir: "/tmp/plugin",
+    };
+    const git = {
+      sha: "e83c5163316f89bfbde7d9ab23ca2e25604af290",
+      repo: "me/my-plugin",
+      dirty: false,
+      pushed: true,
+      pluginPath: "",
+    };
+
+    const payload = buildPublishPayload(validation, git, "productivity");
+
+    expect(payload.name).toBe("my-plugin");
+    expect(payload.source.source).toBe("github");
+    expect(payload.source.repo).toBe("me/my-plugin");
+    expect(payload.source.ref).toBe("e83c5163316f89bfbde7d9ab23ca2e25604af290");
+    expect(payload.source.path).toBeUndefined();
+    expect(payload.category).toBe("productivity");
+    expect(payload.description).toBe("Does cool stuff");
+    expect(payload.license).toBe("MIT");
+    expect(payload.homepage).toBe("https://github.com/me/my-plugin");
+  });
+
+  it("sets source.path for nested plugin roots", () => {
+    const validation: PublishValidation = {
+      valid: true,
+      issues: [],
+      warnings: [],
+      packageJson: {
+        name: "my-plugin",
+        version: "1.0.0",
+        peerDependencies: { "@vellumai/plugin-api": "^1.0.0" },
+      },
+      pluginDir: "/tmp/monorepo/packages/plugin",
+    };
+    const git = {
+      sha: "e83c5163316f89bfbde7d9ab23ca2e25604af290",
+      repo: "me/monorepo",
+      dirty: false,
+      pushed: true,
+      pluginPath: "packages/plugin",
+    };
+
+    const payload = buildPublishPayload(validation, git, "other");
+    expect(payload.source.path).toBe("packages/plugin");
+  });
+
+  it("extracts homepage from repository.url when homepage is absent", () => {
+    const validation: PublishValidation = {
+      valid: true,
+      issues: [],
+      warnings: [],
+      packageJson: {
+        name: "my-plugin",
+        version: "1.0.0",
+        peerDependencies: { "@vellumai/plugin-api": "^1.0.0" },
+        repository: { url: "https://github.com/me/my-plugin.git" },
+      },
+      pluginDir: "/tmp/plugin",
+    };
+    const git = {
+      sha: "e83c5163316f89bfbde7d9ab23ca2e25604af290",
+      repo: "me/my-plugin",
+      dirty: false,
+      pushed: true,
+      pluginPath: "",
+    };
+
+    const payload = buildPublishPayload(validation, git, "other");
+    expect(payload.homepage).toBe("https://github.com/me/my-plugin");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+describe("formatPayloadForPrint", () => {
+  it("produces valid JSON", () => {
+    const payload = {
+      name: "test",
+      source: { source: "github" as const, repo: "me/test", ref: "abc" },
+      category: "other",
+    };
+    const printed = formatPayloadForPrint(payload);
+    expect(JSON.parse(printed)).toEqual(payload);
+  });
+});
+
+describe("formatPublishResult", () => {
+  it("formats success", () => {
+    const result = formatPublishResult({
+      ok: true,
+      pr_url: "https://github.com/vellum-ai/vellum-assistant/pull/1",
+      pr_number: 1,
+      status: "pending_review",
+    });
+    expect(result).toContain("PR opened");
+    expect(result).toContain("review");
+  });
+
+  it("formats failure", () => {
+    const result = formatPublishResult({
+      ok: false,
+      error: "rate_limited",
+      message: "Too many publishes.",
+    });
+    expect(result).toContain("failed");
+    expect(result).toContain("Too many publishes");
+  });
+});
+
+describe("formatValidationResult", () => {
+  it("formats errors and warnings", () => {
+    const result = formatValidationResult({
+      valid: false,
+      issues: ["Missing name"],
+      warnings: ["No surfaces"],
+      packageJson: {},
+      pluginDir: "/tmp",
+    });
+    expect(result).toContain("Validation errors");
+    expect(result).toContain("Missing name");
+    expect(result).toContain("Warnings");
+    expect(result).toContain("No surfaces");
+  });
+
+  it("formats clean validation", () => {
+    const result = formatValidationResult({
+      valid: true,
+      issues: [],
+      warnings: [],
+      packageJson: {},
+      pluginDir: "/tmp",
+    });
+    expect(result).toContain("passed");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runPublish (CLI entrypoint)
+// ---------------------------------------------------------------------------
+
+describe("runPublish", () => {
+  it("returns false on denied confirmation without submitting", async () => {
+    const dir = makePluginDir(tmpdir(), validPkg, { hooks: true });
+    // Initialize a git repo so resolveGitContext doesn't fail
+    const { execSync } = await import("node:child_process");
+    const gitEnv = {
+      ...process.env,
+      GIT_AUTHOR_NAME: "Test",
+      GIT_AUTHOR_EMAIL: "test@test.com",
+      GIT_COMMITTER_NAME: "Test",
+      GIT_COMMITTER_EMAIL: "test@test.com",
+    };
+    execSync("git init && git add -A && git commit -m init", {
+      cwd: dir,
+      stdio: "ignore",
+      env: gitEnv,
+    });
+    execSync("git remote add origin https://github.com/test/test-plugin.git", {
+      cwd: dir,
+      stdio: "ignore",
+      env: gitEnv,
+    });
+
+    const ok = await runPublish(
+      { path: dir, force: false, json: false },
+      {
+        confirmPrompt: async () => "denied",
+      },
+    );
+
+    expect(ok).toBe(false);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns true on --print without submitting", async () => {
+    const dir = makePluginDir(tmpdir(), validPkg, { hooks: true });
+
+    const ok = await runPublish(
+      { path: dir, print: true, json: true },
+      {
+        confirmPrompt: async () => {
+          throw new Error("should not be called");
+        },
+      },
+    );
+
+    expect(ok).toBe(true);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns false when no package.json found", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "no-pkg-"));
+    const ok = await runPublish(
+      { path: dir, force: true, json: true },
+      {
+        confirmPrompt: async () => {
+          throw new Error("should not be called");
+        },
+      },
+    );
+
+    expect(ok).toBe(false);
+    rmSync(dir, { recursive: true });
+  });
+});

package/src/cli/lib/list-installed-plugins.ts

@@ -13,10 +13,25 @@
  */
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 
+/**
+ * Directory containing first-party default plugin packages. Each subdirectory
+ * has a `package.json` with `name` (prefixed `default-`) and `version`.
+ * Read from the filesystem at call time to avoid pulling hook/tool
+ * implementations into the CLI process (which would create circular
+ * dependencies in test environments).
+ */
+const DEFAULT_PLUGINS_DIR = join(
+  dirname(new URL(import.meta.url).pathname),
+  "..",
+  "..",
+  "plugins",
+  "defaults",
+);
+
 /** Minimal manifest fields surfaced to the CLI. */
 export interface PluginPackageMetadata {
   readonly name?: string;
@@ -40,6 +55,20 @@ export interface InstalledPluginInfo {
   readonly issues: readonly string[];
 }
 
+/** Where the plugin comes from. */
+export type PluginSource = "user" | "default";
+
+/**
+ * Extended plugin entry that includes source (`user` vs `default`) and
+ * disabled status. Used by {@link listAllPlugins}.
+ */
+export interface AllPluginInfo extends InstalledPluginInfo {
+  /** Whether this is a user-installed or first-party default plugin. */
+  readonly source: PluginSource;
+  /** Whether the plugin is disabled via a `.disabled` sentinel file. */
+  readonly disabled: boolean;
+}
+
 /** Options accepted by {@link listInstalledPlugins}. */
 export interface ListInstalledPluginsOptions {
   /** Override the workspace plugins directory. Falls back to {@link getWorkspacePluginsDir}. */
@@ -146,3 +175,152 @@ function readPluginEntry(
 
   return { name, target, packageJson, issues };
 }
+
+/**
+ * List all plugins — both user-installed (from `<workspace>/plugins/`) and
+ * first-party defaults (from the source tree). Each entry is annotated with
+ * its `source` (`"user"` or `"default"`) and `disabled` status (whether a
+ * `.disabled` sentinel file exists in the plugin's workspace directory).
+ *
+ * For user plugins, the `.disabled` file lives in the plugin's own install
+ * directory. For default plugins, it lives in a stub directory at
+ * `<workspace>/plugins/<manifest-name>/` (created by `plugins disable`).
+ *
+ * Stub directories created by `plugins disable <default-name>` are excluded
+ * from the user listing so a disabled default plugin appears only once (as a
+ * default entry, not a duplicate user entry with "missing package.json").
+ *
+ * Sort order:
+ * 1. Enabled user plugins (by install date, oldest first — matches
+ *    hook/tool resolution order)
+ * 2. Disabled user plugins (by install date)
+ * 3. Enabled default plugins (by repo array order — matches registration
+ *    order which fixes hook-chain order)
+ * 4. Disabled default plugins (by repo array order)
+ */
+export function listAllPlugins(
+  opts: ListInstalledPluginsOptions = {},
+): AllPluginInfo[] {
+  const pluginsDir = opts.workspacePluginsDir ?? getWorkspacePluginsDir();
+
+  // ── User plugins ───────────────────────────────────────────────────────
+  // Filter out default-plugin stub directories (created by `plugins disable
+  // default-<name>`) so they don't show up as duplicate user entries.
+  const defaultNames = new Set(
+    readDefaultPluginManifests().map((m) => m.name),
+  );
+  const userPlugins: AllPluginInfo[] = listInstalledPlugins(opts)
+    .filter((entry) => !defaultNames.has(entry.name))
+    .map((entry) => ({
+      ...entry,
+      source: "user" as const,
+      disabled: existsSync(join(entry.target, ".disabled")),
+    }));
+
+  // ── Default plugins ────────────────────────────────────────────────────
+  // Default plugins live in the source tree at src/plugins/defaults/<name>/.
+  // Read each package.json from the filesystem to get name+version without
+  // importing hook/tool implementations (which would create circular
+  // dependencies in test environments). The .disabled sentinel lives in a
+  // stub directory at <workspace>/plugins/<manifest-name>/.
+  // readDefaultPluginManifests returns in repo array (registration) order.
+  const defaultPlugins: AllPluginInfo[] = readDefaultPluginManifests().map(
+    (manifest) => {
+      const target = join(pluginsDir, manifest.name);
+      const disabled = existsSync(join(target, ".disabled"));
+      return {
+        name: manifest.name,
+        target,
+        packageJson: {
+          name: manifest.name,
+          version: manifest.version,
+        },
+        issues: [],
+        source: "default" as const,
+        disabled,
+      };
+    },
+  );
+
+  // Sort: enabled user (install date), disabled user (install date),
+  // enabled default (repo order), disabled default (repo order).
+  const enabledUser = userPlugins.filter((p) => !p.disabled);
+  const disabledUser = userPlugins.filter((p) => p.disabled);
+  const enabledDefault = defaultPlugins.filter((p) => !p.disabled);
+  const disabledDefault = defaultPlugins.filter((p) => p.disabled);
+
+  enabledUser.sort((a, b) => getPluginInstallDate(a) - getPluginInstallDate(b));
+  disabledUser.sort(
+    (a, b) => getPluginInstallDate(a) - getPluginInstallDate(b),
+  );
+  // enabledDefault and disabledDefault keep repo array order (no sort).
+
+  return [...enabledUser, ...disabledUser, ...enabledDefault, ...disabledDefault];
+}
+
+interface DefaultPluginManifest {
+  readonly name: string;
+  readonly version?: string;
+}
+
+/**
+ * Read first-party default plugin manifests from the filesystem. Each
+ * subdirectory under {@link DEFAULT_PLUGINS_DIR} that has a `package.json`
+ * with a `name` field is included. This avoids importing `defaults/index.ts`
+ * (which would pull in hook/tool implementations and create circular
+ * dependencies in test environments).
+ */
+function readDefaultPluginManifests(): readonly DefaultPluginManifest[] {
+  if (!existsSync(DEFAULT_PLUGINS_DIR)) return [];
+
+  const entries = readdirSync(DEFAULT_PLUGINS_DIR, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .sort();
+
+  const manifests: DefaultPluginManifest[] = [];
+  for (const name of entries) {
+    const pkgJsonPath = join(DEFAULT_PLUGINS_DIR, name, "package.json");
+    if (!existsSync(pkgJsonPath)) continue;
+    try {
+      const raw = readFileSync(pkgJsonPath, "utf8");
+      const parsed = JSON.parse(raw) as Record<string, unknown>;
+      if (typeof parsed.name === "string") {
+        manifests.push({
+          name: parsed.name,
+          version:
+            typeof parsed.version === "string" ? parsed.version : undefined,
+        });
+      }
+    } catch {
+      // Skip malformed entries — lenient like listInstalledPlugins.
+    }
+  }
+  return manifests;
+}
+
+/**
+ * Resolve the install date for a user plugin directory, in epoch ms.
+ * Reads `install-meta.json`'s `installedAt` field first, falling back to
+ * the directory's birthtime. Mirrors the logic in mtime-cache's
+ * `getInstallDate` so the sort order matches hook/tool resolution order.
+ */
+function getPluginInstallDate(plugin: AllPluginInfo): number {
+  const metaPath = join(plugin.target, "install-meta.json");
+  try {
+    if (existsSync(metaPath)) {
+      const raw = JSON.parse(readFileSync(metaPath, "utf8")) as Record<string, unknown>;
+      if (typeof raw.installedAt === "string") {
+        const ms = Date.parse(raw.installedAt);
+        if (Number.isFinite(ms)) return ms;
+      }
+    }
+  } catch {
+    // Fall through to birthtime.
+  }
+  try {
+    return statSync(plugin.target).birthtimeMs;
+  } catch {
+    return 0;
+  }
+}