fix(plugins): make the plugin system actually work — 5 breaks, closes #165

src/index.ts

@@ -22,6 +22,7 @@ import { installZsh, uninstallZsh } from "./commands/hook.js";
 import { syncSetup, syncRun, syncStatus } from "./commands/sync.js";
 import { listExtensions, enableExtension, disableExtension, installExtension } from "./commands/extension.js";
 import { PluginLoader } from "./lib/plugin.js";
+import { registerPluginCommands } from "./lib/plugin-commands.js";
 import { doctor } from "./commands/doctor.js";
 import { briefCommand } from "./commands/brief.js";
 import { chittyCommand } from "./commands/chitty.js";
@@ -123,7 +124,7 @@ if (firstArg && firstArg in CLI_CONFIGS) {
   process.exit(0);
 }
 
-yargs(args)
+const cli = yargs(args)
   .scriptName("can")
   .usage("$0 <command> [options]")
   .command(
@@ -1246,6 +1247,14 @@ yargs(args)
     process.exit(1);
   })
   .demandCommand(1, "You must provide a command")
+  ;
+
+// Plugin commands must be registered BEFORE .strict(), which rejects anything unknown.
+// loadAll() populated the loader above; without this call getAllCommands() was never
+// consumed and every plugin-supplied command was unreachable.
+registerPluginCommands(cli, pluginLoader.getAllCommands(), config);
+
+cli
   .strict()
   .help()
   .alias("h", "help")

src/lib/plugin-commands.ts

@@ -0,0 +1,76 @@
+import type { Argv } from "yargs";
+import type { CommandDefinition } from "./plugin.js";
+import type { Config } from "./config.js";
+
+/**
+ * Register plugin-supplied commands with yargs.
+ *
+ * Plugin command names are space-separated paths ("neon branch list"), not yargs command
+ * strings. Passing one straight to `.command()` would declare a command `neon` taking two
+ * positionals called `branch` and `list` — accepting `can neon foo bar` and rejecting
+ * nothing. So the names are first assembled into a tree and registered as nested commands.
+ *
+ * Leaf handlers receive yargs' argv plus the CLI config, matching CommandDefinition.
+ */
+
+interface Node {
+  children: Map<string, Node>;
+  leaf?: CommandDefinition;
+}
+
+export function buildCommandTree(commands: CommandDefinition[]): Node {
+  const root: Node = { children: new Map() };
+  for (const cmd of commands) {
+    const parts = cmd.name.trim().split(/\s+/).filter(Boolean);
+    if (parts.length === 0) continue;
+    let node = root;
+    for (const part of parts) {
+      let next = node.children.get(part);
+      if (!next) {
+        next = { children: new Map() };
+        node.children.set(part, next);
+      }
+      node = next;
+    }
+    // Last definition wins, matching the loader's "a configured extension wins" ordering.
+    node.leaf = cmd;
+  }
+  return root;
+}
+
+function describe(node: Node, name: string): string {
+  if (node.leaf) return node.leaf.description;
+  const kids = Array.from(node.children.keys()).join(", ");
+  return `${name} subcommands: ${kids}`;
+}
+
+function registerNode(y: Argv, name: string, node: Node, config: Config): Argv {
+  return y.command(
+    node.children.size > 0 ? `${name} <subcommand>` : name,
+    describe(node, name),
+    (sub: Argv) => {
+      for (const [childName, child] of node.children) {
+        registerNode(sub, childName, child, config);
+      }
+      if (node.leaf?.options) sub.options(node.leaf.options);
+      // A branch with children but no handler of its own must not silently succeed.
+      return node.children.size > 0 ? sub.demandCommand(1, `Specify a ${name} subcommand`) : sub;
+    },
+    async (argv: any) => {
+      if (!node.leaf?.handler) return;
+      await node.leaf.handler(argv, config);
+    }
+  );
+}
+
+export function registerPluginCommands(
+  cli: Argv,
+  commands: CommandDefinition[],
+  config: Config
+): Argv {
+  const root = buildCommandTree(commands);
+  for (const [name, node] of root.children) {
+    registerNode(cli, name, node, config);
+  }
+  return cli;
+}

src/lib/plugin.ts

@@ -102,6 +102,8 @@ export class PluginLoader {
    * Load all plugins from config
    */
   async loadAll(): Promise<void> {
+    await this.loadBundledPlugins();
+
     const extensions = this.config.extensions || {};
 
     for (const [name, extConfig] of Object.entries(extensions)) {
@@ -116,6 +118,40 @@ export class PluginLoader {
     }
   }
 
+  /**
+   * Load the plugins that ship inside this package.
+   *
+   * These are listed explicitly rather than discovered by scanning: a directory scan at
+   * startup costs a stat per entry on every `can` invocation, and an explicit list fails
+   * loudly in review when a plugin is added without being registered.
+   *
+   * Measured cost of importing all of these: ~17ms against a ~280ms baseline startup.
+   *
+   * `ai/` and `chittyos/` are deliberately absent — their index modules are barrel files
+   * that re-export helpers and expose no `metadata`, so they are not plugins.
+   */
+  private async loadBundledPlugins(): Promise<void> {
+    const bundled = [
+      () => import("../plugins/cloudflare/index.js"),
+      () => import("../plugins/linear/index.js"),
+      () => import("../plugins/neon/index.js")
+    ];
+
+    for (const load of bundled) {
+      try {
+        const mod: any = await load();
+        const plugin: ChittyPlugin = mod.default || mod;
+        if (!this.isValidPlugin(plugin)) continue;
+        if (this.plugins.has(plugin.metadata.name)) continue; // a configured extension wins
+        this.plugins.set(plugin.metadata.name, plugin);
+        if (plugin.init) await plugin.init(this.config);
+      } catch (error: any) {
+        // Never let a bundled plugin break every command. Report, do not throw.
+        console.warn(`[chitty] Failed to load bundled plugin: ${error.message}`);
+      }
+    }
+  }
+
   /**
    * Get a loaded plugin
    */

src/plugins/ai/anthropic.ts

@@ -1,6 +1,6 @@
 import type { ChittyPlugin, CommandDefinition, RemoteTypeDefinition } from "@/lib/plugin";
 import type { Config } from "@/lib/config";
-import { CHITTYCLAW_PROVIDER_BASE_URLS, gatewayAuthHeaders } from "./gateway";
+import { CHITTYCLAW_PROVIDER_BASE_URLS, gatewayAuthHeaders } from "./gateway.js";
 
 interface AnthropicRemote {
   type: "anthropic";

src/plugins/ai/openai.ts

@@ -1,6 +1,6 @@
 import type { ChittyPlugin, CommandDefinition, RemoteTypeDefinition } from "@/lib/plugin";
 import type { Config } from "@/lib/config";
-import { CHITTYCLAW_PROVIDER_BASE_URLS, gatewayAuthHeaders } from "./gateway";
+import { CHITTYCLAW_PROVIDER_BASE_URLS, gatewayAuthHeaders } from "./gateway.js";
 
 interface OpenAIRemote {
   type: "openai";

src/plugins/cloudflare/index.ts

@@ -191,7 +191,6 @@ const CloudflarePlugin: ChittyPlugin = {
   ],
 
   async init(config: Config) {
-    console.log("[chitty] Cloudflare extension loaded");
   },
 };
 

src/plugins/linear/index.ts

@@ -266,7 +266,6 @@ const LinearPlugin: ChittyPlugin = {
   ],
 
   async init(config: Config) {
-    console.log("[chitty] Linear extension loaded");
   },
 };
 

src/plugins/neon/index.ts

@@ -224,7 +224,6 @@ const NeonPlugin: ChittyPlugin = {
   ],
 
   async init(config: Config) {
-    console.log("[chitty] Neon extension loaded");
   },
 };
 

tests/plugin-commands.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from "vitest";
+import { buildCommandTree, registerPluginCommands } from "../src/lib/plugin-commands.js";
+import { PluginLoader } from "../src/lib/plugin.js";
+import type { CommandDefinition } from "../src/lib/plugin.js";
+
+const cmd = (name: string): CommandDefinition => ({ name, description: `desc ${name}`, handler: async () => {} });
+
+describe("buildCommandTree", () => {
+  it("nests a space-separated name instead of treating it as positionals", () => {
+    // The whole reason this module exists: yargs would read "neon branch list" as a
+    // command `neon` taking two positionals, accepting `can neon foo bar`.
+    const root = buildCommandTree([cmd("neon branch list")]);
+    const neon = root.children.get("neon")!;
+    expect(neon).toBeDefined();
+    expect(neon.leaf).toBeUndefined();
+    const branch = neon.children.get("branch")!;
+    expect(branch.leaf).toBeUndefined();
+    expect(branch.children.get("list")!.leaf!.name).toBe("neon branch list");
+  });
+
+  it("shares intermediate nodes across sibling commands", () => {
+    const root = buildCommandTree([cmd("neon branch list"), cmd("neon branch create"), cmd("neon db list")]);
+    const neon = root.children.get("neon")!;
+    expect([...neon.children.keys()].sort()).toEqual(["branch", "db"]);
+    expect([...neon.children.get("branch")!.children.keys()].sort()).toEqual(["create", "list"]);
+  });
+
+  it("supports a single-word command", () => {
+    const root = buildCommandTree([cmd("linear teams")]);
+    expect(root.children.get("linear")!.children.get("teams")!.leaf!.name).toBe("linear teams");
+  });
+
+  it("allows a node to be both a leaf and a parent", () => {
+    const root = buildCommandTree([cmd("linear issues"), cmd("linear issue create")]);
+    const linear = root.children.get("linear")!;
+    expect(linear.children.get("issues")!.leaf).toBeDefined();
+    expect(linear.children.get("issue")!.leaf).toBeUndefined();
+  });
+
+  it("ignores an empty or whitespace-only name rather than creating a blank node", () => {
+    const root = buildCommandTree([cmd("   "), cmd("")]);
+    expect(root.children.size).toBe(0);
+  });
+
+  it("collapses repeated whitespace", () => {
+    const root = buildCommandTree([cmd("cf   worker    list")]);
+    expect(root.children.get("cf")!.children.get("worker")!.children.get("list")!.leaf).toBeDefined();
+  });
+});
+
+describe("registerPluginCommands", () => {
+  it("registers one top-level yargs command per root child", () => {
+    const seen: string[] = [];
+    const fakeYargs: any = { command: (name: string) => { seen.push(name); return fakeYargs; } };
+    registerPluginCommands(fakeYargs, [cmd("neon branch list"), cmd("cf worker list")], {} as any);
+    expect(seen.sort()).toEqual(["cf <subcommand>", "neon <subcommand>"]);
+  });
+
+  it("passes the config through to the leaf handler", async () => {
+    let received: unknown = null;
+    const def: CommandDefinition = { name: "x go", description: "d", handler: async (_a, c) => { received = c; } };
+    const captured: any[] = [];
+    const fakeYargs: any = {
+      command: (_n: string, _d: string, builder: any, handler: any) => {
+        captured.push({ builder, handler });
+        builder({ command: fakeYargs.command, options: () => fakeYargs, demandCommand: () => fakeYargs });
+        return fakeYargs;
+      },
+      options: () => fakeYargs,
+      demandCommand: () => fakeYargs
+    };
+    const config = { marker: 42 } as any;
+    registerPluginCommands(fakeYargs, [def], config);
+    const leaf = captured[captured.length - 1];
+    await leaf.handler({});
+    expect(received).toBe(config);
+  });
+});
+
+describe("PluginLoader bundled plugins — real modules, no mocks", () => {
+  it("loads the in-tree plugins that shipped unreachable before this fix", async () => {
+    const loader = new PluginLoader({} as any);
+    await loader.loadAll();
+    const names = loader.getAllPlugins().map(p => p.metadata.name).sort();
+    expect(names).toEqual(["@chitty/cloudflare", "@chitty/linear", "@chitty/neon"]);
+  });
+
+  it("exposes their commands through getAllCommands, which nothing used to call", async () => {
+    const loader = new PluginLoader({} as any);
+    await loader.loadAll();
+    const names = loader.getAllCommands().map(c => c.name);
+    expect(names).toContain("neon branch list");
+    expect(names.length).toBeGreaterThanOrEqual(8);
+  });
+});