create-pragma-plugin 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# create-pragma-plugin
+
+Scaffold a Pragma plugin. Part of [Pragma](https://github.com/pragma-sh/pragma) — a desktop workspace for
+running persistent, worktree-scoped coding agents.
+
+Generates a self-contained Vite project for a pure-TypeScript Pragma plugin:
+a single ESM bundle, React aliased to the host's instance, and a test setup.
+
+```sh
+bun create pragma-plugin my-plugin
+# or: npm create pragma-plugin my-plugin
+```
+
+Capabilities: `ui` (sidebar tab), `commands`, `agents`. Pass
+`--capabilities ui,commands` to skip the prompt.
+
+Docs: <https://pragma-app.sh/docs/plugins/getting-started>
+
+## License
+
+AGPL-3.0-only. See [LICENSE](https://github.com/pragma-sh/pragma/blob/main/LICENSE).

package/dist/cli.cjs

@@ -0,0 +1,418 @@
+#!/usr/bin/env node
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/cli.ts
+var import_promises2 = require("node:readline/promises");
+var import_node_process = require("node:process");
+
+// src/scaffold.ts
+var import_promises = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+
+// src/names.ts
+function normalizePluginName(input) {
+  const name = input.trim().replace(/^@/, "").replaceAll(/[^a-zA-Z0-9._~-]+/g, "-").replaceAll(/^-+|-+$/g, "").toLowerCase();
+  return name || "pragma-plugin";
+}
+
+// src/package-manager.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var LOCKFILES = [
+  ["bun", ["bun.lock", "bun.lockb"]],
+  ["pnpm", ["pnpm-lock.yaml"]],
+  ["yarn", ["yarn.lock"]],
+  ["npm", ["package-lock.json"]]
+];
+function detectPackageManager(startDir = process.cwd()) {
+  let current = import_node_path.resolve(startDir);
+  const root = import_node_path.parse(current).root;
+  while (true) {
+    for (const [manager, files] of LOCKFILES) {
+      if (files.some((file) => import_node_fs.existsSync(import_node_path.join(current, file)))) {
+        return manager;
+      }
+    }
+    if (current === root) {
+      return "bun";
+    }
+    current = import_node_path.dirname(current);
+  }
+}
+// package.json
+var version = "0.1.0";
+
+// src/templates.ts
+function pluginTemplate(input) {
+  return [
+    { path: "package.json", contents: packageJson(input) },
+    { path: "tsconfig.json", contents: tsconfigJson() },
+    { path: "vite.config.ts", contents: viteConfig() },
+    { path: "README.md", contents: readme(input) },
+    { path: "src/index.tsx", contents: source(input) },
+    { path: "src/index.test.ts", contents: testSource() }
+  ];
+}
+function packageJson(input) {
+  return `${JSON.stringify({
+    name: input.packageName,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    main: "./dist/index.js",
+    scripts: {
+      build: "vite build",
+      dev: "vite build --watch",
+      typecheck: "tsc --noEmit",
+      test: "vitest run"
+    },
+    dependencies: {
+      "@pragma-sh/plugin": `^${version}`
+    },
+    devDependencies: {
+      "@types/react": "^19.2.14",
+      "@types/react-dom": "^19.2.3",
+      "@vitejs/plugin-react": "^6.0.2",
+      typescript: "^6.0.3",
+      vite: "^8.0.16",
+      vitest: "^4.1.8",
+      react: "^19.2.6",
+      "react-dom": "^19.2.6"
+    }
+  }, null, 2)}
+`;
+}
+function tsconfigJson() {
+  return `${JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      lib: ["ES2022", "DOM", "DOM.Iterable"],
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      jsx: "react-jsx",
+      jsxImportSource: "react",
+      strict: true,
+      noEmit: true,
+      skipLibCheck: true
+    },
+    include: ["src"]
+  }, null, 2)}
+`;
+}
+function viteConfig() {
+  return `import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      "react/jsx-runtime": "@pragma-sh/plugin/jsx-runtime",
+      "react-dom": "@pragma-sh/plugin/react-dom",
+      react: "@pragma-sh/plugin/react",
+    },
+  },
+  build: {
+    lib: {
+      entry: "src/index.tsx",
+      formats: ["es"],
+      fileName: "index",
+    },
+    rollupOptions: {
+      output: {
+        inlineDynamicImports: true,
+      },
+    },
+  },
+});
+`;
+}
+function source(input) {
+  const hasCommand = input.capabilities.includes("commands");
+  const commandImport = hasCommand ? ", defineCommand" : "";
+  const commandContribution = hasCommand ? `,
+  commands: [
+    defineCommand({
+      id: "${input.packageName}.hello",
+      title: "Show ${input.displayName} greeting",
+      run: (ctx) => ctx.notify("Hello from ${input.displayName}", { variant: "success" }),
+    }),
+  ]` : "";
+  return `import { definePlugin, defineSidebarTab, useProject${commandImport} } from "@pragma-sh/plugin";
+import { Button, Kbd } from "@pragma-sh/plugin/ui";
+
+function OverviewTab() {
+  const project = useProject();
+  return (
+    <div style={{ padding: 12 }}>
+      <h2>${input.displayName}</h2>
+      <p>Active project: {project?.name ?? "None"}</p>
+      <Button variant="secondary" size="sm">
+        Press <Kbd>⌘K</Kbd>
+      </Button>
+    </div>
+  );
+}
+
+export default definePlugin({
+  name: "${input.displayName}",
+  description: "A Pragma plugin scaffolded with create-pragma-plugin.",
+  ui: {
+    sidebarTabs: [
+      defineSidebarTab({
+        id: "overview",
+        title: "${input.displayName}",
+        component: OverviewTab,
+      }),
+    ],
+  }${commandContribution},
+});
+`;
+}
+function testSource() {
+  return `import { describe, expect, it } from "vitest";
+
+import plugin from "./index";
+
+describe("plugin", () => {
+  it("exports a stamped Pragma plugin", () => {
+    expect(plugin.__apiVersion).toBeTypeOf("string");
+    expect(plugin.name).toBeTypeOf("string");
+  });
+});
+`;
+}
+function readme(input) {
+  const install = input.packageManager === "npm" ? "npm install" : `${input.packageManager} install`;
+  const run = input.packageManager === "npm" ? "npm run" : `${input.packageManager} run`;
+  return `# ${input.displayName}
+
+A Pragma plugin scaffolded with \`create-pragma-plugin\`.
+
+## Quick Start
+
+\`\`\`bash
+${install}
+${run} build
+\`\`\`
+
+## Load In Pragma
+
+Add this to your project's \`.pragma/config.json\`:
+
+\`\`\`json
+{
+  "plugins": [{ "path": "./${input.directoryName}" }]
+}
+\`\`\`
+
+Pragma loads local plugin code from this path. Only add plugins you trust.
+
+## Commands
+
+\`\`\`bash
+${run} dev
+${run} typecheck
+${run} test
+${run} build
+\`\`\`
+`;
+}
+
+// src/scaffold.ts
+async function scaffoldPlugin(options) {
+  const directory = import_node_path2.resolve(options.directory);
+  const packageName = normalizePluginName(options.name ?? import_node_path2.basename(directory));
+  const packageManager = options.packageManager ?? detectPackageManager(process.cwd());
+  const capabilities = options.capabilities?.length ? options.capabilities : ["ui"];
+  await assertWritableDirectory(directory, options.force === true);
+  const files = pluginTemplate({
+    packageName,
+    displayName: titleCase(packageName),
+    directoryName: import_node_path2.basename(directory),
+    packageManager,
+    capabilities
+  });
+  for (const file of files) {
+    const path = import_node_path2.join(directory, file.path);
+    await import_promises.mkdir(import_node_path2.join(path, ".."), { recursive: true });
+    await import_promises.writeFile(path, file.contents);
+  }
+  return { directory, packageName, packageManager, files: files.map((file) => file.path) };
+}
+async function assertWritableDirectory(directory, force) {
+  try {
+    const entries = await import_promises.readdir(directory);
+    if (!force && entries.length > 0) {
+      throw new Error(`destination is not empty: ${directory}`);
+    }
+  } catch (cause) {
+    if (cause instanceof Error && "code" in cause && cause.code === "ENOENT") {
+      await import_promises.mkdir(directory, { recursive: true });
+      return;
+    }
+    throw cause;
+  }
+}
+function titleCase(packageName) {
+  return packageName.split(/[._~-]+/g).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+}
+
+// src/cli.ts
+var CAPABILITIES = new Set(["ui", "commands", "agents"]);
+var PACKAGE_MANAGERS = new Set(["bun", "npm", "pnpm", "yarn"]);
+var HELP_FLAGS = new Set(["--help", "-h"]);
+var VALUE_FLAG_HANDLERS = {
+  "--capabilities": (args, value) => {
+    args.capabilities = parseCapabilities(value);
+  },
+  "--name": (args, value) => {
+    args.name = value;
+  },
+  "--pm": (args, value) => {
+    args.packageManager = parsePackageManager(value);
+  }
+};
+async function main(argv) {
+  const options = await parseScaffoldOptions(argv);
+  if (!options) {
+    return;
+  }
+  const result = await scaffoldPlugin(options);
+  import_node_process.stdout.write(`Created ${result.packageName} in ${result.directory}
+`);
+  import_node_process.stdout.write(`Next: ${result.packageManager} install && ${result.packageManager} run build
+`);
+}
+async function parseScaffoldOptions(argv) {
+  const args = parseArgs(argv);
+  if (!args.directory) {
+    printUsage();
+    process.exitCode = 1;
+    return null;
+  }
+  return {
+    directory: args.directory,
+    ...optionalName(args.name),
+    packageManager: args.packageManager ?? detectPackageManager(),
+    capabilities: args.capabilities ?? await promptCapabilities(),
+    force: args.force
+  };
+}
+function optionalName(name) {
+  return name === undefined ? {} : { name };
+}
+function parseArgs(argv) {
+  const args = { directory: null, force: false, capabilities: null };
+  for (let index = 0;index < argv.length; ) {
+    index = parseArg(argv, args, index);
+  }
+  return args;
+}
+function parseArg(argv, args, index) {
+  const arg = argv[index];
+  return arg === undefined ? index + 1 : parsePresentArg(argv, args, index, arg);
+}
+function parsePresentArg(argv, args, index, arg) {
+  const valueHandler = VALUE_FLAG_HANDLERS[arg];
+  if (valueHandler) {
+    valueHandler(args, requireValue(argv, index + 1, arg));
+    return index + 2;
+  }
+  if (arg === "--force") {
+    args.force = true;
+    return index + 1;
+  }
+  if (HELP_FLAGS.has(arg)) {
+    printUsage();
+    process.exit(0);
+  }
+  return parseDirectoryArg(args, index, arg);
+}
+function parseDirectoryArg(args, index, arg) {
+  if (!args.directory) {
+    args.directory = arg;
+    return index + 1;
+  }
+  throw new Error(`unexpected argument: ${arg}`);
+}
+function requireValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}
+function parsePackageManager(value) {
+  if (PACKAGE_MANAGERS.has(value)) {
+    return value;
+  }
+  throw new Error(`unsupported package manager: ${value}`);
+}
+function parseCapabilities(value) {
+  const selected = value.split(",").map((part) => part.trim()).filter(Boolean);
+  for (const capability of selected) {
+    if (!CAPABILITIES.has(capability)) {
+      throw new Error(`unsupported capability: ${capability}`);
+    }
+  }
+  return selected;
+}
+async function promptCapabilities() {
+  if (!import_node_process.stdin.isTTY || !import_node_process.stdout.isTTY) {
+    return ["ui"];
+  }
+  const rl = import_promises2.createInterface({ input: import_node_process.stdin, output: import_node_process.stdout });
+  try {
+    const answer = await rl.question("Capabilities (comma-separated: ui, commands, agents) [ui,commands]: ");
+    return answer.trim() ? parseCapabilities(answer) : ["ui", "commands"];
+  } finally {
+    rl.close();
+  }
+}
+function printUsage() {
+  import_node_process.stdout.write(`Usage: create-pragma-plugin <directory> [--name <package-name>] [--pm bun|npm|pnpm|yarn] [--capabilities ui,commands,agents] [--force]
+`);
+}
+main(process.argv.slice(2)).catch((cause) => {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  console.error(message);
+  process.exitCode = 1;
+});

package/dist/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import {
+  detectPackageManager,
+  scaffoldPlugin
+} from "./shared/chunk-8xnme2e1.js";
+
+// src/cli.ts
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+var CAPABILITIES = new Set(["ui", "commands", "agents"]);
+var PACKAGE_MANAGERS = new Set(["bun", "npm", "pnpm", "yarn"]);
+var HELP_FLAGS = new Set(["--help", "-h"]);
+var VALUE_FLAG_HANDLERS = {
+  "--capabilities": (args, value) => {
+    args.capabilities = parseCapabilities(value);
+  },
+  "--name": (args, value) => {
+    args.name = value;
+  },
+  "--pm": (args, value) => {
+    args.packageManager = parsePackageManager(value);
+  }
+};
+async function main(argv) {
+  const options = await parseScaffoldOptions(argv);
+  if (!options) {
+    return;
+  }
+  const result = await scaffoldPlugin(options);
+  output.write(`Created ${result.packageName} in ${result.directory}
+`);
+  output.write(`Next: ${result.packageManager} install && ${result.packageManager} run build
+`);
+}
+async function parseScaffoldOptions(argv) {
+  const args = parseArgs(argv);
+  if (!args.directory) {
+    printUsage();
+    process.exitCode = 1;
+    return null;
+  }
+  return {
+    directory: args.directory,
+    ...optionalName(args.name),
+    packageManager: args.packageManager ?? detectPackageManager(),
+    capabilities: args.capabilities ?? await promptCapabilities(),
+    force: args.force
+  };
+}
+function optionalName(name) {
+  return name === undefined ? {} : { name };
+}
+function parseArgs(argv) {
+  const args = { directory: null, force: false, capabilities: null };
+  for (let index = 0;index < argv.length; ) {
+    index = parseArg(argv, args, index);
+  }
+  return args;
+}
+function parseArg(argv, args, index) {
+  const arg = argv[index];
+  return arg === undefined ? index + 1 : parsePresentArg(argv, args, index, arg);
+}
+function parsePresentArg(argv, args, index, arg) {
+  const valueHandler = VALUE_FLAG_HANDLERS[arg];
+  if (valueHandler) {
+    valueHandler(args, requireValue(argv, index + 1, arg));
+    return index + 2;
+  }
+  if (arg === "--force") {
+    args.force = true;
+    return index + 1;
+  }
+  if (HELP_FLAGS.has(arg)) {
+    printUsage();
+    process.exit(0);
+  }
+  return parseDirectoryArg(args, index, arg);
+}
+function parseDirectoryArg(args, index, arg) {
+  if (!args.directory) {
+    args.directory = arg;
+    return index + 1;
+  }
+  throw new Error(`unexpected argument: ${arg}`);
+}
+function requireValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}
+function parsePackageManager(value) {
+  if (PACKAGE_MANAGERS.has(value)) {
+    return value;
+  }
+  throw new Error(`unsupported package manager: ${value}`);
+}
+function parseCapabilities(value) {
+  const selected = value.split(",").map((part) => part.trim()).filter(Boolean);
+  for (const capability of selected) {
+    if (!CAPABILITIES.has(capability)) {
+      throw new Error(`unsupported capability: ${capability}`);
+    }
+  }
+  return selected;
+}
+async function promptCapabilities() {
+  if (!input.isTTY || !output.isTTY) {
+    return ["ui"];
+  }
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question("Capabilities (comma-separated: ui, commands, agents) [ui,commands]: ");
+    return answer.trim() ? parseCapabilities(answer) : ["ui", "commands"];
+  } finally {
+    rl.close();
+  }
+}
+function printUsage() {
+  output.write(`Usage: create-pragma-plugin <directory> [--name <package-name>] [--pm bun|npm|pnpm|yarn] [--capabilities ui,commands,agents] [--force]
+`);
+}
+main(process.argv.slice(2)).catch((cause) => {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  console.error(message);
+  process.exitCode = 1;
+});

package/dist/index.cjs

@@ -0,0 +1,299 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  scaffoldPlugin: () => scaffoldPlugin,
+  normalizePluginName: () => normalizePluginName,
+  detectPackageManager: () => detectPackageManager
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/package-manager.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var LOCKFILES = [
+  ["bun", ["bun.lock", "bun.lockb"]],
+  ["pnpm", ["pnpm-lock.yaml"]],
+  ["yarn", ["yarn.lock"]],
+  ["npm", ["package-lock.json"]]
+];
+function detectPackageManager(startDir = process.cwd()) {
+  let current = import_node_path.resolve(startDir);
+  const root = import_node_path.parse(current).root;
+  while (true) {
+    for (const [manager, files] of LOCKFILES) {
+      if (files.some((file) => import_node_fs.existsSync(import_node_path.join(current, file)))) {
+        return manager;
+      }
+    }
+    if (current === root) {
+      return "bun";
+    }
+    current = import_node_path.dirname(current);
+  }
+}
+// src/scaffold.ts
+var import_promises = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+
+// src/names.ts
+function normalizePluginName(input) {
+  const name = input.trim().replace(/^@/, "").replaceAll(/[^a-zA-Z0-9._~-]+/g, "-").replaceAll(/^-+|-+$/g, "").toLowerCase();
+  return name || "pragma-plugin";
+}
+// package.json
+var version = "0.1.0";
+
+// src/templates.ts
+function pluginTemplate(input) {
+  return [
+    { path: "package.json", contents: packageJson(input) },
+    { path: "tsconfig.json", contents: tsconfigJson() },
+    { path: "vite.config.ts", contents: viteConfig() },
+    { path: "README.md", contents: readme(input) },
+    { path: "src/index.tsx", contents: source(input) },
+    { path: "src/index.test.ts", contents: testSource() }
+  ];
+}
+function packageJson(input) {
+  return `${JSON.stringify({
+    name: input.packageName,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    main: "./dist/index.js",
+    scripts: {
+      build: "vite build",
+      dev: "vite build --watch",
+      typecheck: "tsc --noEmit",
+      test: "vitest run"
+    },
+    dependencies: {
+      "@pragma-sh/plugin": `^${version}`
+    },
+    devDependencies: {
+      "@types/react": "^19.2.14",
+      "@types/react-dom": "^19.2.3",
+      "@vitejs/plugin-react": "^6.0.2",
+      typescript: "^6.0.3",
+      vite: "^8.0.16",
+      vitest: "^4.1.8",
+      react: "^19.2.6",
+      "react-dom": "^19.2.6"
+    }
+  }, null, 2)}
+`;
+}
+function tsconfigJson() {
+  return `${JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      lib: ["ES2022", "DOM", "DOM.Iterable"],
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      jsx: "react-jsx",
+      jsxImportSource: "react",
+      strict: true,
+      noEmit: true,
+      skipLibCheck: true
+    },
+    include: ["src"]
+  }, null, 2)}
+`;
+}
+function viteConfig() {
+  return `import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      "react/jsx-runtime": "@pragma-sh/plugin/jsx-runtime",
+      "react-dom": "@pragma-sh/plugin/react-dom",
+      react: "@pragma-sh/plugin/react",
+    },
+  },
+  build: {
+    lib: {
+      entry: "src/index.tsx",
+      formats: ["es"],
+      fileName: "index",
+    },
+    rollupOptions: {
+      output: {
+        inlineDynamicImports: true,
+      },
+    },
+  },
+});
+`;
+}
+function source(input) {
+  const hasCommand = input.capabilities.includes("commands");
+  const commandImport = hasCommand ? ", defineCommand" : "";
+  const commandContribution = hasCommand ? `,
+  commands: [
+    defineCommand({
+      id: "${input.packageName}.hello",
+      title: "Show ${input.displayName} greeting",
+      run: (ctx) => ctx.notify("Hello from ${input.displayName}", { variant: "success" }),
+    }),
+  ]` : "";
+  return `import { definePlugin, defineSidebarTab, useProject${commandImport} } from "@pragma-sh/plugin";
+import { Button, Kbd } from "@pragma-sh/plugin/ui";
+
+function OverviewTab() {
+  const project = useProject();
+  return (
+    <div style={{ padding: 12 }}>
+      <h2>${input.displayName}</h2>
+      <p>Active project: {project?.name ?? "None"}</p>
+      <Button variant="secondary" size="sm">
+        Press <Kbd>⌘K</Kbd>
+      </Button>
+    </div>
+  );
+}
+
+export default definePlugin({
+  name: "${input.displayName}",
+  description: "A Pragma plugin scaffolded with create-pragma-plugin.",
+  ui: {
+    sidebarTabs: [
+      defineSidebarTab({
+        id: "overview",
+        title: "${input.displayName}",
+        component: OverviewTab,
+      }),
+    ],
+  }${commandContribution},
+});
+`;
+}
+function testSource() {
+  return `import { describe, expect, it } from "vitest";
+
+import plugin from "./index";
+
+describe("plugin", () => {
+  it("exports a stamped Pragma plugin", () => {
+    expect(plugin.__apiVersion).toBeTypeOf("string");
+    expect(plugin.name).toBeTypeOf("string");
+  });
+});
+`;
+}
+function readme(input) {
+  const install = input.packageManager === "npm" ? "npm install" : `${input.packageManager} install`;
+  const run = input.packageManager === "npm" ? "npm run" : `${input.packageManager} run`;
+  return `# ${input.displayName}
+
+A Pragma plugin scaffolded with \`create-pragma-plugin\`.
+
+## Quick Start
+
+\`\`\`bash
+${install}
+${run} build
+\`\`\`
+
+## Load In Pragma
+
+Add this to your project's \`.pragma/config.json\`:
+
+\`\`\`json
+{
+  "plugins": [{ "path": "./${input.directoryName}" }]
+}
+\`\`\`
+
+Pragma loads local plugin code from this path. Only add plugins you trust.
+
+## Commands
+
+\`\`\`bash
+${run} dev
+${run} typecheck
+${run} test
+${run} build
+\`\`\`
+`;
+}
+
+// src/scaffold.ts
+async function scaffoldPlugin(options) {
+  const directory = import_node_path2.resolve(options.directory);
+  const packageName = normalizePluginName(options.name ?? import_node_path2.basename(directory));
+  const packageManager = options.packageManager ?? detectPackageManager(process.cwd());
+  const capabilities = options.capabilities?.length ? options.capabilities : ["ui"];
+  await assertWritableDirectory(directory, options.force === true);
+  const files = pluginTemplate({
+    packageName,
+    displayName: titleCase(packageName),
+    directoryName: import_node_path2.basename(directory),
+    packageManager,
+    capabilities
+  });
+  for (const file of files) {
+    const path = import_node_path2.join(directory, file.path);
+    await import_promises.mkdir(import_node_path2.join(path, ".."), { recursive: true });
+    await import_promises.writeFile(path, file.contents);
+  }
+  return { directory, packageName, packageManager, files: files.map((file) => file.path) };
+}
+async function assertWritableDirectory(directory, force) {
+  try {
+    const entries = await import_promises.readdir(directory);
+    if (!force && entries.length > 0) {
+      throw new Error(`destination is not empty: ${directory}`);
+    }
+  } catch (cause) {
+    if (cause instanceof Error && "code" in cause && cause.code === "ENOENT") {
+      await import_promises.mkdir(directory, { recursive: true });
+      return;
+    }
+    throw cause;
+  }
+}
+function titleCase(packageName) {
+  return packageName.split(/[._~-]+/g).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+}

package/dist/index.d.cts

@@ -0,0 +1,22 @@
+type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
+/** Detects the nearest package manager by walking up from `startDir` and checking lockfiles. */
+declare function detectPackageManager(startDir?: string): PackageManager;
+type ScaffoldCapability = "ui" | "commands" | "agents";
+interface ScaffoldOptions {
+	directory: string;
+	name?: string;
+	packageManager?: PackageManager;
+	capabilities?: readonly ScaffoldCapability[];
+	force?: boolean;
+}
+interface ScaffoldResult {
+	directory: string;
+	packageName: string;
+	packageManager: PackageManager;
+	files: string[];
+}
+/** Creates a new Pragma plugin project from the built-in TypeScript template. */
+declare function scaffoldPlugin(options: ScaffoldOptions): Promise<ScaffoldResult>;
+/** Converts a directory or package name into a valid lowercase npm package name. */
+declare function normalizePluginName(input: string): string;
+export { scaffoldPlugin, normalizePluginName, detectPackageManager, ScaffoldResult, ScaffoldOptions, ScaffoldCapability, PackageManager };

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
+/** Detects the nearest package manager by walking up from `startDir` and checking lockfiles. */
+declare function detectPackageManager(startDir?: string): PackageManager;
+type ScaffoldCapability = "ui" | "commands" | "agents";
+interface ScaffoldOptions {
+	directory: string;
+	name?: string;
+	packageManager?: PackageManager;
+	capabilities?: readonly ScaffoldCapability[];
+	force?: boolean;
+}
+interface ScaffoldResult {
+	directory: string;
+	packageName: string;
+	packageManager: PackageManager;
+	files: string[];
+}
+/** Creates a new Pragma plugin project from the built-in TypeScript template. */
+declare function scaffoldPlugin(options: ScaffoldOptions): Promise<ScaffoldResult>;
+/** Converts a directory or package name into a valid lowercase npm package name. */
+declare function normalizePluginName(input: string): string;
+export { scaffoldPlugin, normalizePluginName, detectPackageManager, ScaffoldResult, ScaffoldOptions, ScaffoldCapability, PackageManager };

package/dist/index.js

@@ -0,0 +1,10 @@
+import {
+  detectPackageManager,
+  normalizePluginName,
+  scaffoldPlugin
+} from "./shared/chunk-8xnme2e1.js";
+export {
+  scaffoldPlugin,
+  normalizePluginName,
+  detectPackageManager
+};

package/dist/shared/chunk-8xnme2e1.js

@@ -0,0 +1,254 @@
+// src/package-manager.ts
+import { existsSync } from "node:fs";
+import { dirname, join, parse, resolve } from "node:path";
+var LOCKFILES = [
+  ["bun", ["bun.lock", "bun.lockb"]],
+  ["pnpm", ["pnpm-lock.yaml"]],
+  ["yarn", ["yarn.lock"]],
+  ["npm", ["package-lock.json"]]
+];
+function detectPackageManager(startDir = process.cwd()) {
+  let current = resolve(startDir);
+  const root = parse(current).root;
+  while (true) {
+    for (const [manager, files] of LOCKFILES) {
+      if (files.some((file) => existsSync(join(current, file)))) {
+        return manager;
+      }
+    }
+    if (current === root) {
+      return "bun";
+    }
+    current = dirname(current);
+  }
+}
+
+// src/names.ts
+function normalizePluginName(input) {
+  const name = input.trim().replace(/^@/, "").replaceAll(/[^a-zA-Z0-9._~-]+/g, "-").replaceAll(/^-+|-+$/g, "").toLowerCase();
+  return name || "pragma-plugin";
+}
+
+// src/scaffold.ts
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { basename, join as join2, resolve as resolve2 } from "node:path";
+// package.json
+var version = "0.1.0";
+
+// src/templates.ts
+function pluginTemplate(input) {
+  return [
+    { path: "package.json", contents: packageJson(input) },
+    { path: "tsconfig.json", contents: tsconfigJson() },
+    { path: "vite.config.ts", contents: viteConfig() },
+    { path: "README.md", contents: readme(input) },
+    { path: "src/index.tsx", contents: source(input) },
+    { path: "src/index.test.ts", contents: testSource() }
+  ];
+}
+function packageJson(input) {
+  return `${JSON.stringify({
+    name: input.packageName,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    main: "./dist/index.js",
+    scripts: {
+      build: "vite build",
+      dev: "vite build --watch",
+      typecheck: "tsc --noEmit",
+      test: "vitest run"
+    },
+    dependencies: {
+      "@pragma-sh/plugin": `^${version}`
+    },
+    devDependencies: {
+      "@types/react": "^19.2.14",
+      "@types/react-dom": "^19.2.3",
+      "@vitejs/plugin-react": "^6.0.2",
+      typescript: "^6.0.3",
+      vite: "^8.0.16",
+      vitest: "^4.1.8",
+      react: "^19.2.6",
+      "react-dom": "^19.2.6"
+    }
+  }, null, 2)}
+`;
+}
+function tsconfigJson() {
+  return `${JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      lib: ["ES2022", "DOM", "DOM.Iterable"],
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      jsx: "react-jsx",
+      jsxImportSource: "react",
+      strict: true,
+      noEmit: true,
+      skipLibCheck: true
+    },
+    include: ["src"]
+  }, null, 2)}
+`;
+}
+function viteConfig() {
+  return `import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      "react/jsx-runtime": "@pragma-sh/plugin/jsx-runtime",
+      "react-dom": "@pragma-sh/plugin/react-dom",
+      react: "@pragma-sh/plugin/react",
+    },
+  },
+  build: {
+    lib: {
+      entry: "src/index.tsx",
+      formats: ["es"],
+      fileName: "index",
+    },
+    rollupOptions: {
+      output: {
+        inlineDynamicImports: true,
+      },
+    },
+  },
+});
+`;
+}
+function source(input) {
+  const hasCommand = input.capabilities.includes("commands");
+  const commandImport = hasCommand ? ", defineCommand" : "";
+  const commandContribution = hasCommand ? `,
+  commands: [
+    defineCommand({
+      id: "${input.packageName}.hello",
+      title: "Show ${input.displayName} greeting",
+      run: (ctx) => ctx.notify("Hello from ${input.displayName}", { variant: "success" }),
+    }),
+  ]` : "";
+  return `import { definePlugin, defineSidebarTab, useProject${commandImport} } from "@pragma-sh/plugin";
+import { Button, Kbd } from "@pragma-sh/plugin/ui";
+
+function OverviewTab() {
+  const project = useProject();
+  return (
+    <div style={{ padding: 12 }}>
+      <h2>${input.displayName}</h2>
+      <p>Active project: {project?.name ?? "None"}</p>
+      <Button variant="secondary" size="sm">
+        Press <Kbd>⌘K</Kbd>
+      </Button>
+    </div>
+  );
+}
+
+export default definePlugin({
+  name: "${input.displayName}",
+  description: "A Pragma plugin scaffolded with create-pragma-plugin.",
+  ui: {
+    sidebarTabs: [
+      defineSidebarTab({
+        id: "overview",
+        title: "${input.displayName}",
+        component: OverviewTab,
+      }),
+    ],
+  }${commandContribution},
+});
+`;
+}
+function testSource() {
+  return `import { describe, expect, it } from "vitest";
+
+import plugin from "./index";
+
+describe("plugin", () => {
+  it("exports a stamped Pragma plugin", () => {
+    expect(plugin.__apiVersion).toBeTypeOf("string");
+    expect(plugin.name).toBeTypeOf("string");
+  });
+});
+`;
+}
+function readme(input) {
+  const install = input.packageManager === "npm" ? "npm install" : `${input.packageManager} install`;
+  const run = input.packageManager === "npm" ? "npm run" : `${input.packageManager} run`;
+  return `# ${input.displayName}
+
+A Pragma plugin scaffolded with \`create-pragma-plugin\`.
+
+## Quick Start
+
+\`\`\`bash
+${install}
+${run} build
+\`\`\`
+
+## Load In Pragma
+
+Add this to your project's \`.pragma/config.json\`:
+
+\`\`\`json
+{
+  "plugins": [{ "path": "./${input.directoryName}" }]
+}
+\`\`\`
+
+Pragma loads local plugin code from this path. Only add plugins you trust.
+
+## Commands
+
+\`\`\`bash
+${run} dev
+${run} typecheck
+${run} test
+${run} build
+\`\`\`
+`;
+}
+
+// src/scaffold.ts
+async function scaffoldPlugin(options) {
+  const directory = resolve2(options.directory);
+  const packageName = normalizePluginName(options.name ?? basename(directory));
+  const packageManager = options.packageManager ?? detectPackageManager(process.cwd());
+  const capabilities = options.capabilities?.length ? options.capabilities : ["ui"];
+  await assertWritableDirectory(directory, options.force === true);
+  const files = pluginTemplate({
+    packageName,
+    displayName: titleCase(packageName),
+    directoryName: basename(directory),
+    packageManager,
+    capabilities
+  });
+  for (const file of files) {
+    const path = join2(directory, file.path);
+    await mkdir(join2(path, ".."), { recursive: true });
+    await writeFile(path, file.contents);
+  }
+  return { directory, packageName, packageManager, files: files.map((file) => file.path) };
+}
+async function assertWritableDirectory(directory, force) {
+  try {
+    const entries = await readdir(directory);
+    if (!force && entries.length > 0) {
+      throw new Error(`destination is not empty: ${directory}`);
+    }
+  } catch (cause) {
+    if (cause instanceof Error && "code" in cause && cause.code === "ENOENT") {
+      await mkdir(directory, { recursive: true });
+      return;
+    }
+    throw cause;
+  }
+}
+function titleCase(packageName) {
+  return packageName.split(/[._~-]+/g).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+}
+
+export { detectPackageManager, normalizePluginName, scaffoldPlugin };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "create-pragma-plugin",
+  "version": "0.1.0",
+  "description": "Scaffolder CLI for pure TypeScript Pragma plugins.",
+  "homepage": "https://github.com/pragma-sh/pragma#readme",
+  "bugs": "https://github.com/pragma-sh/pragma/issues",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pragma-sh/pragma.git",
+    "directory": "packages/create-pragma-plugin"
+  },
+  "bin": {
+    "create-pragma-plugin": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bunup src/index.ts src/cli.ts --format esm,cjs --target node --dts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun --bun vitest run",
+    "lint": "oxlint ."
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.3",
+    "bunup": "^0.16.32",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  }
+}