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

package/src/cli/commands/plugins.ts

@@ -29,7 +29,11 @@ import {
   PluginAlreadyInstalledError,
   PluginNotFoundError,
 } from "../lib/install-from-github.js";
-import { listInstalledPlugins } from "../lib/list-installed-plugins.js";
+import {
+  type AllPluginInfo,
+  listAllPlugins,
+  listInstalledPlugins,
+} from "../lib/list-installed-plugins.js";
 import type { FingerprintComparison } from "../lib/plugin-fingerprint.js";
 import {
   DEFAULT_PIN_HISTORY_LIMIT,
@@ -38,6 +42,7 @@ import {
   PluginPinHistoryError,
   resolvePinToMarketplaceCommit,
 } from "../lib/plugin-pin-history.js";
+import { runPublish } from "../lib/publish-plugin.js";
 import { registerCommand } from "../lib/register-command.js";
 import {
   InvalidSearchPatternError,
@@ -85,6 +90,8 @@ Examples:
   $ assistant plugins install example --pin <sha> --force
   $ assistant plugins list
   $ assistant plugins list --json
+  $ assistant plugins list --all
+  $ assistant plugins list --all --json
   $ assistant plugins inspect example
   $ assistant plugins inspect example --json
   $ assistant plugins diff example
@@ -155,7 +162,6 @@ Examples:
               console.log(
                 `Installed plugin "${result.name}" (${result.fileCount} file${result.fileCount === 1 ? "" : "s"})${pinned} → ${result.target}`,
               );
-              console.log("Restart the assistant to pick up the new plugin.");
             } catch (err) {
               if (err instanceof PluginAlreadyInstalledError) {
                 console.error(`${err.message}\nPass --force to overwrite.`);
@@ -239,9 +245,58 @@ Examples:
 
       plugins
         .command("list")
-        .description("List plugins installed under <workspaceDir>/plugins/")
+        .description("List plugins installed in your workspace.")
         .option("--json", "Emit machine-readable JSON instead of a table")
-        .action((opts: { json?: boolean }) => {
+        .option(
+          "--all",
+          "Include first-party default plugins and disabled plugins in the listing",
+        )
+        .action((opts: { json?: boolean; all?: boolean }) => {
+          if (opts.all) {
+            const all = listAllPlugins();
+
+            if (opts.json) {
+              process.stdout.write(JSON.stringify(all, null, 2) + "\n");
+              return;
+            }
+
+            if (all.length === 0) {
+              console.log("No plugins found.");
+              return;
+            }
+
+            const rows = all.map((p) => ({
+              name: p.name,
+              version: p.packageJson?.version ?? "—",
+              source: p.source,
+              status: formatAllPluginStatus(p),
+            }));
+            const nameW = Math.max(4, ...rows.map((r) => r.name.length));
+            const versionW = Math.max(7, ...rows.map((r) => r.version.length));
+            const sourceW = Math.max(6, ...rows.map((r) => r.source.length));
+            const pad = (s: string, w: number) => s + " ".repeat(w - s.length);
+            console.log(
+              `${pad("NAME", nameW)}  ${pad("VERSION", versionW)}  ${pad("SOURCE", sourceW)}  STATUS`,
+            );
+            for (const r of rows) {
+              console.log(
+                `${pad(r.name, nameW)}  ${pad(r.version, versionW)}  ${pad(r.source, sourceW)}  ${r.status}`,
+              );
+            }
+
+            const userCount = all.filter((p) => p.source === "user").length;
+            const defaultCount = all.length - userCount;
+            const disabledCount = all.filter((p) => p.disabled).length;
+            console.log("");
+            console.log(
+              `${all.length} plugin${all.length === 1 ? "" : "s"} ` +
+                `(${userCount} user, ${defaultCount} default` +
+                (disabledCount > 0 ? `, ${disabledCount} disabled` : "") +
+                `).`,
+            );
+            return;
+          }
+
           const installed = listInstalledPlugins();
 
           if (opts.json) {
@@ -451,6 +506,56 @@ Examples:
           }
         });
 
+      plugins
+        .command("publish")
+        .description(
+          "Validate and submit the plugin in the current directory to the Vellum marketplace catalog",
+        )
+        .option(
+          "--print",
+          "Print the entry JSON without submitting to the platform",
+        )
+        .option(
+          "--path <dir>",
+          "Validate a plugin at the given path instead of CWD",
+        )
+        .option("--force", "Skip the confirmation prompt")
+        .option("--json", "Emit machine-readable JSON instead of human output")
+        .option(
+          "--category <cat>",
+          "Set the category, skipping the interactive prompt",
+        )
+        .addHelpText(
+          "after",
+          `
+
+Validates the plugin in the current directory (or --path), resolves the
+git commit SHA and GitHub remote, and submits the entry to the Vellum
+platform API. The platform creates a pull request against
+vellum-ai/vellum-assistant adding the plugin to the marketplace catalog.
+
+Requires a connected Vellum platform account (run \`assistant platform connect\`).
+Use --print to validate and print the entry without submitting.
+
+Examples:
+$ assistant plugins publish
+$ assistant plugins publish --print
+$ assistant plugins publish --path ./my-plugin --category productivity
+$ assistant plugins publish --json`,
+        )
+        .action(
+          async (opts: {
+            print?: boolean;
+            path?: string;
+            force?: boolean;
+            json?: boolean;
+            category?: string;
+          }) => {
+            const ok = await runPublish(opts, { confirmPrompt });
+            if (!ok) process.exitCode = 1;
+          },
+        );
+
       plugins
         .command("uninstall <name>")
         .description("Remove a plugin from <workspaceDir>/plugins/<name>/")
@@ -480,7 +585,6 @@ Examples:
             console.log(
               `Uninstalled plugin "${result.name}" from ${result.target}`,
             );
-            console.log("Restart the assistant to drop the plugin.");
           } catch (err) {
             if (err instanceof InvalidPluginNameError) {
               console.error(err.message);
@@ -501,15 +605,13 @@ Examples:
       plugins
         .command("disable <name>")
         .description(
-          "Disable a plugin by creating a .disabled sentinel file. Works for both user-installed and default plugins. Restart the assistant for the change to take effect.",
+          "Disable a plugin by creating a .disabled sentinel file. Works for both user-installed and default plugins. Takes effect immediately in a running assistant.",
         )
         .action((name: string) => {
           try {
             const result = disablePlugin(name);
             log.info({ name: result.name }, "plugin disabled");
-            console.log(
-              `Disabled plugin "${result.name}". Restart the assistant for the change to take effect.`,
-            );
+            console.log(`Disabled plugin "${result.name}".`);
           } catch (err) {
             if (
               err instanceof PluginAlreadyInStateException ||
@@ -529,15 +631,13 @@ Examples:
       plugins
         .command("enable <name>")
         .description(
-          "Re-enable a disabled plugin by removing the .disabled sentinel file. Restart the assistant for the change to take effect.",
+          "Re-enable a disabled plugin by removing the .disabled sentinel file. Takes effect immediately.",
         )
         .action((name: string) => {
           try {
             const result = enablePlugin(name);
             log.info({ name: result.name }, "plugin enabled");
-            console.log(
-              `Enabled plugin "${result.name}". Restart the assistant for the change to take effect.`,
-            );
+            console.log(`Enabled plugin "${result.name}".`);
           } catch (err) {
             if (
               err instanceof PluginAlreadyInStateException ||
@@ -757,6 +857,18 @@ function formatTimestamp(iso: string | null): string {
   return new Date(ms).toISOString().slice(0, 19);
 }
 
+/**
+ * Build a human-readable status string for a plugin in the `--all` listing.
+ * Combines disabled state with any structural issues.
+ */
+function formatAllPluginStatus(p: AllPluginInfo): string {
+  const parts: string[] = [];
+  if (p.disabled) parts.push("disabled");
+  if (p.issues.length > 0) parts.push(p.issues.join("; "));
+  if (parts.length === 0) parts.push("enabled");
+  return parts.join(", ");
+}
+
 /** Human-readable status line for an inspection result. The from/to revisions
  * now live in the installed/remote blocks, so the status itself is just words. */
 function statusLine(status: PluginInspection["status"]): string {

package/src/cli/lib/__tests__/install-from-github.test.ts

@@ -436,6 +436,108 @@ describe("installPlugin — marketplace resolution", () => {
     expect(meta.contentHash).toMatch(/^v2:[0-9a-f]{64}$/);
   });
 
+  test("installs a plugin rooted at a sub-path, copying only that subtree", async () => {
+    // GIVEN a marketplace entry whose source pins a directory *within* a repo
+    // (a monorepo that ships several plugins) rather than the repo root.
+    const NESTED_SHA = "0f".repeat(20);
+    const NESTED_MANIFEST = {
+      name: "vellum-assistant",
+      plugins: [
+        {
+          name: "nested-plugin",
+          source: {
+            source: "github",
+            repo: "example-org/monorepo",
+            path: "packages/my-plugin",
+            ref: NESTED_SHA,
+          },
+          description: "A plugin that lives in a monorepo sub-directory.",
+        },
+      ],
+    };
+    const fetch = makeContentsFetch({ tree: {}, manifest: NESTED_MANIFEST });
+    // The clone carries files both at the repo root and under the pinned
+    // sub-path; only the sub-path subtree should be materialized.
+    const runGit = fakeGitRunner({
+      tree: {
+        "package.json": '{"name":"monorepo-root"}',
+        "README.md": "# monorepo root",
+        "packages/my-plugin/package.json": '{"name":"nested-plugin"}',
+        "packages/my-plugin/README.md": "# nested plugin",
+        "packages/my-plugin/hooks/init.ts": "export default async () => {};",
+        "packages/other-plugin/package.json": '{"name":"other"}',
+      },
+      commit: NESTED_SHA,
+    });
+
+    // WHEN we install by name
+    const result = await installPlugin(
+      { name: "nested-plugin", ref: "main" },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    // THEN only the sub-path subtree lands, rooted at <pluginsDir>/nested-plugin
+    const target = join(pluginsDir, "nested-plugin");
+    expect(result.target).toBe(target);
+    expect(readFileSync(join(target, "package.json"), "utf-8")).toBe(
+      '{"name":"nested-plugin"}',
+    );
+    expect(existsSync(join(target, "README.md"))).toBe(true);
+    expect(existsSync(join(target, "hooks", "init.ts"))).toBe(true);
+    // AND the repo-root and sibling-package files are NOT copied in — the
+    // install is scoped to the pinned directory.
+    expect(result.fileCount).toBe(3);
+    expect(readFileSync(join(target, "package.json"), "utf-8")).not.toContain(
+      "monorepo-root",
+    );
+    expect(existsSync(join(target, "packages"))).toBe(false);
+
+    // AND provenance records the sub-path so an upgrade/diff re-resolves the
+    // same directory rather than the repo root.
+    const meta = readInstallMeta(target);
+    expect(meta?.source.owner).toBe("example-org");
+    expect(meta?.source.repo).toBe("monorepo");
+    expect(meta?.source.path).toBe("packages/my-plugin");
+    expect(meta?.source.ref).toBe(NESTED_SHA);
+  });
+
+  test("a sub-path that does not exist in the clone surfaces a clean not-found", async () => {
+    // GIVEN an entry pinning a directory the cloned ref doesn't contain
+    const MISSING_SHA = "1a".repeat(20);
+    const MISSING_PATH_MANIFEST = {
+      name: "vellum-assistant",
+      plugins: [
+        {
+          name: "nested-plugin",
+          source: {
+            source: "github",
+            repo: "example-org/monorepo",
+            path: "packages/does-not-exist",
+            ref: MISSING_SHA,
+          },
+        },
+      ],
+    };
+    const fetch = makeContentsFetch({
+      tree: {},
+      manifest: MISSING_PATH_MANIFEST,
+    });
+    const runGit = fakeGitRunner({
+      tree: { "package.json": '{"name":"monorepo-root"}' },
+      commit: MISSING_SHA,
+    });
+
+    // WHEN we install
+    // THEN the absent sub-path yields a hard not-found and nothing is staged
+    await expect(
+      installPlugin(
+        { name: "nested-plugin", ref: "main" },
+        { fetch, runGit, workspacePluginsDir: pluginsDir },
+      ),
+    ).rejects.toBeInstanceOf(PluginNotFoundError);
+    expect(readdirSync(pluginsDir)).toEqual([]);
+  });
+
   test("refuses to install when the checked-out commit differs from the pinned SHA", async () => {
     // GIVEN a clone whose resolved HEAD does not match the manifest's pinned
     // commit SHA — i.e. the upstream object served something unexpected

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

@@ -17,7 +17,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { listInstalledPlugins } from "../list-installed-plugins.js";
+import { listAllPlugins, listInstalledPlugins } from "../list-installed-plugins.js";
 
 let pluginsDir: string;
 
@@ -152,3 +152,162 @@ describe("listInstalledPlugins", () => {
     expect(result.map((p) => p.name)).toEqual(["valid"]);
   });
 });
+
+describe("listAllPlugins", () => {
+  test("includes default plugins with source=default", () => {
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const defaults = result.filter((p) => p.source === "default");
+    // All 14 default plugins should be present.
+    expect(defaults.length).toBe(14);
+    // Names should all start with "default-".
+    expect(defaults.every((p) => p.name.startsWith("default-"))).toBe(true);
+    // None should be disabled by default in a fresh temp dir.
+    expect(defaults.every((p) => !p.disabled)).toBe(true);
+  });
+
+  test("includes user plugins with source=user", () => {
+    mkdirSync(join(pluginsDir, "my-plugin"));
+    writeFileSync(
+      join(pluginsDir, "my-plugin", "package.json"),
+      JSON.stringify({ name: "my-plugin", version: "1.0.0" }),
+    );
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const user = result.filter((p) => p.source === "user");
+    expect(user).toHaveLength(1);
+    expect(user[0]!.name).toBe("my-plugin");
+    expect(user[0]!.disabled).toBe(false);
+  });
+
+  test("user plugins appear before default plugins", () => {
+    mkdirSync(join(pluginsDir, "zzz-user"));
+    writeFileSync(
+      join(pluginsDir, "zzz-user", "package.json"),
+      JSON.stringify({ name: "zzz-user", version: "1.0.0" }),
+    );
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const firstDefaultIdx = result.findIndex((p) => p.source === "default");
+    const lastUserIdx = result
+      .map((p, i) => (p.source === "user" ? i : -1))
+      .filter((i) => i >= 0)
+      .pop();
+
+    expect(lastUserIdx).toBeDefined();
+    expect(firstDefaultIdx).toBeGreaterThan(lastUserIdx!);
+  });
+
+  test("detects disabled state for user plugins", () => {
+    mkdirSync(join(pluginsDir, "my-plugin"));
+    writeFileSync(
+      join(pluginsDir, "my-plugin", "package.json"),
+      JSON.stringify({ name: "my-plugin", version: "1.0.0" }),
+    );
+    writeFileSync(join(pluginsDir, "my-plugin", ".disabled"), "");
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const entry = result.find((p) => p.name === "my-plugin");
+    expect(entry).toBeDefined();
+    expect(entry!.disabled).toBe(true);
+  });
+
+  test("detects disabled state for default plugins via stub directory", () => {
+    mkdirSync(join(pluginsDir, "default-compaction"), { recursive: true });
+    writeFileSync(join(pluginsDir, "default-compaction", ".disabled"), "");
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const compaction = result.find((p) => p.name === "default-compaction");
+    expect(compaction).toBeDefined();
+    expect(compaction!.disabled).toBe(true);
+  });
+
+  test("default stub directory is excluded from user listing", () => {
+    mkdirSync(join(pluginsDir, "default-compaction"), { recursive: true });
+    writeFileSync(join(pluginsDir, "default-compaction", ".disabled"), "");
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    // Should appear exactly once, as a default entry (not a user entry).
+    const compactionEntries = result.filter((p) => p.name === "default-compaction");
+    expect(compactionEntries).toHaveLength(1);
+    expect(compactionEntries[0]!.source).toBe("default");
+  });
+
+  test("sort order: enabled user, disabled user, enabled default, disabled default", () => {
+    // User plugins
+    mkdirSync(join(pluginsDir, "aaa-enabled"));
+    writeFileSync(
+      join(pluginsDir, "aaa-enabled", "package.json"),
+      JSON.stringify({ name: "aaa-enabled", version: "1.0.0" }),
+    );
+    mkdirSync(join(pluginsDir, "bbb-disabled"));
+    writeFileSync(
+      join(pluginsDir, "bbb-disabled", "package.json"),
+      JSON.stringify({ name: "bbb-disabled", version: "1.0.0" }),
+    );
+    writeFileSync(join(pluginsDir, "bbb-disabled", ".disabled"), "");
+
+    // Disable one default plugin
+    mkdirSync(join(pluginsDir, "default-compaction"), { recursive: true });
+    writeFileSync(join(pluginsDir, "default-compaction", ".disabled"), "");
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+
+    const enabledUserIdx = result.findIndex(
+      (p) => p.source === "user" && !p.disabled,
+    );
+    const disabledUserIdx = result.findIndex(
+      (p) => p.source === "user" && p.disabled,
+    );
+    const enabledDefaultIdx = result.findIndex(
+      (p) => p.source === "default" && !p.disabled,
+    );
+    const disabledDefaultIdx = result.findIndex(
+      (p) => p.source === "default" && p.disabled,
+    );
+
+    // All groups present.
+    expect(enabledUserIdx).toBeGreaterThanOrEqual(0);
+    expect(disabledUserIdx).toBeGreaterThan(enabledUserIdx);
+    expect(enabledDefaultIdx).toBeGreaterThan(disabledUserIdx);
+    expect(disabledDefaultIdx).toBeGreaterThan(enabledDefaultIdx);
+  });
+
+  test("user plugins sorted by install date within each group", () => {
+    // Create two user plugins with different install dates.
+    // First plugin (older).
+    mkdirSync(join(pluginsDir, "older-plugin"));
+    writeFileSync(
+      join(pluginsDir, "older-plugin", "package.json"),
+      JSON.stringify({ name: "older-plugin", version: "1.0.0" }),
+    );
+    writeFileSync(
+      join(pluginsDir, "older-plugin", "install-meta.json"),
+      JSON.stringify({ installedAt: "2025-01-01T00:00:00.000Z" }),
+    );
+
+    // Second plugin (newer).
+    mkdirSync(join(pluginsDir, "newer-plugin"));
+    writeFileSync(
+      join(pluginsDir, "newer-plugin", "package.json"),
+      JSON.stringify({ name: "newer-plugin", version: "1.0.0" }),
+    );
+    writeFileSync(
+      join(pluginsDir, "newer-plugin", "install-meta.json"),
+      JSON.stringify({ installedAt: "2025-06-01T00:00:00.000Z" }),
+    );
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const userPlugins = result.filter((p) => p.source === "user");
+    expect(userPlugins).toHaveLength(2);
+    // Older plugin should come first (install date ascending).
+    expect(userPlugins[0]!.name).toBe("older-plugin");
+    expect(userPlugins[1]!.name).toBe("newer-plugin");
+  });
+
+  test("default plugins have version from their manifest", () => {
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const compaction = result.find((p) => p.name === "default-compaction");
+    expect(compaction).toBeDefined();
+    expect(compaction!.packageJson?.version).toBeTruthy();
+  });
+});