create-brika 0.1.0

package/README.md

@@ -0,0 +1,81 @@
+# create-brika
+
+Scaffold a new BRIKA plugin with a single command.
+
+## Usage
+
+```bash
+bun create brika my-plugin
+```
+
+This launches an interactive wizard that:
+
+1. Asks for plugin details (name, description, category, author)
+2. Fetches the latest SDK version from npm
+3. Creates the complete plugin structure
+4. Installs dependencies
+5. Initializes a git repository
+
+## Options
+
+```bash
+# Interactive mode (prompts for all options)
+bun create brika
+
+# With plugin name
+bun create brika my-plugin
+
+# Skip git initialization
+bun create brika my-plugin --no-git
+
+# Skip dependency installation
+bun create brika my-plugin --no-install
+
+# Show help
+bun create brika --help
+```
+
+## Generated Structure
+
+```
+my-plugin/
+├── package.json          # Plugin manifest with blocks
+├── tsconfig.json         # TypeScript configuration
+├── README.md             # Documentation
+├── .gitignore
+├── src/
+│   └── index.ts          # Block definitions
+└── locales/
+    └── en/
+        └── plugin.json   # i18n translations
+```
+
+## Categories
+
+When prompted for category, choose based on your plugin's purpose:
+
+| Category | Description | Examples |
+|----------|-------------|----------|
+| `trigger` | Starts workflows | Timers, sensors, webhooks |
+| `action` | Performs operations | Send notification, control device |
+| `transform` | Processes data | Map, filter, format |
+| `flow` | Controls execution | Condition, delay, split |
+
+## After Creating
+
+```bash
+cd my-plugin
+bun link          # Link for local development
+bun run tsc       # Type check
+```
+
+Add to your `brika.yml`:
+
+```yaml
+plugins:
+  - path: ./my-plugin
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "create-brika",
+  "version": "0.1.0",
+  "description": "Create a new BRIKA plugin with a single command",
+  "type": "module",
+  "license": "MIT",
+  "author": "BRIKA Team",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maxscharwath/brika.git",
+    "directory": "packages/create-brika"
+  },
+  "keywords": ["brika", "plugin", "scaffold", "cli", "create"],
+  "bin": {
+    "create-brika": "./src/index.ts"
+  },
+  "files": ["src", "template"],
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "tsc": "bunx --bun tsc --noEmit"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.5"
+  }
+}

package/src/index.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env bun
+
+/**
+ * create-brika CLI
+ *
+ * Scaffold a new BRIKA plugin with a single command.
+ *
+ * Usage:
+ *   bun create brika my-plugin
+ *   bunx create-brika my-plugin
+ */
+
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { parseArgs } from 'util';
+import { promptForConfig } from './prompts';
+import { scaffold } from './scaffold';
+
+const HELP = `
+${pc.bold('create-brika')} - Create a new BRIKA plugin
+
+${pc.bold('Usage:')}
+  ${pc.cyan('bun create brika')} ${pc.dim('[plugin-name]')} ${pc.dim('[options]')}
+
+${pc.bold('Options:')}
+  ${pc.cyan('-h, --help')}        Show this help message
+  ${pc.cyan('--no-git')}          Skip git initialization
+  ${pc.cyan('--no-install')}      Skip dependency installation
+
+${pc.bold('Examples:')}
+  ${pc.dim('# Interactive mode')}
+  bun create brika
+
+  ${pc.dim('# With plugin name')}
+  bun create brika my-plugin
+
+  ${pc.dim('# Skip git and install')}
+  bun create brika my-plugin --no-git --no-install
+`;
+
+async function main(): Promise<void> {
+  const { positionals, values } = parseArgs({
+    args: Bun.argv.slice(2),
+    allowPositionals: true,
+    strict: false,
+    options: {
+      help: { type: 'boolean', short: 'h', default: false },
+      git: { type: 'boolean', default: true },
+      install: { type: 'boolean', default: true },
+    },
+  });
+
+  if (values.help) {
+    console.log(HELP);
+    return;
+  }
+
+  try {
+    const config = await promptForConfig(positionals[0]);
+
+    await scaffold({
+      ...config,
+      git: values.git !== false,
+      install: values.install !== false,
+    });
+
+    p.outro(`${pc.green('Success!')} Your plugin is ready at ${pc.cyan(`./${config.name}`)}`);
+
+    console.log();
+    console.log(pc.bold('Next steps:'));
+    console.log(`  ${pc.cyan('cd')} ${config.name}`);
+    console.log(`  ${pc.cyan('bun')} link`);
+    console.log();
+  } catch (error) {
+    if (error instanceof Error && error.message === 'cancelled') {
+      return;
+    }
+    p.cancel('An error occurred');
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+main();

package/src/prompts.ts

@@ -0,0 +1,120 @@
+/**
+ * Interactive prompts for plugin configuration
+ */
+
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { getGitUser } from './utils';
+
+export interface PluginConfig {
+  name: string;
+  description: string;
+  category: 'trigger' | 'action' | 'transform' | 'flow';
+  author: string;
+}
+
+const CATEGORIES = [
+  {
+    value: 'trigger',
+    label: 'Trigger',
+    hint: 'Starts workflows (sensors, timers, webhooks)',
+  },
+  {
+    value: 'action',
+    label: 'Action',
+    hint: 'Performs operations (send, control, notify)',
+  },
+  {
+    value: 'transform',
+    label: 'Transform',
+    hint: 'Processes data (map, filter, format)',
+  },
+  {
+    value: 'flow',
+    label: 'Flow',
+    hint: 'Controls flow (condition, delay, split)',
+  },
+] as const;
+
+/**
+ * Validate plugin name (kebab-case)
+ */
+function validatePluginName(name: string): string | undefined {
+  if (!name) return 'Plugin name is required';
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    return 'Plugin name must be kebab-case (e.g., my-plugin)';
+  }
+  if (name.startsWith('-') || name.endsWith('-')) {
+    return 'Plugin name cannot start or end with a hyphen';
+  }
+  return undefined;
+}
+
+/**
+ * Prompt for plugin configuration
+ */
+export async function promptForConfig(pluginName?: string): Promise<PluginConfig> {
+  p.intro(pc.bgCyan(pc.black(' create-brika ')));
+
+  // Validate provided name
+  if (pluginName) {
+    const error = validatePluginName(pluginName);
+    if (error) {
+      p.cancel(error);
+      throw new Error('cancelled');
+    }
+  }
+
+  const gitUser = await getGitUser();
+
+  const answers = await p.group(
+    {
+      name: () => {
+        if (pluginName) {
+          p.log.info(`Plugin name: ${pc.cyan(pluginName)}`);
+          return Promise.resolve(pluginName);
+        }
+        return p.text({
+          message: 'What is your plugin name?',
+          placeholder: 'my-plugin',
+          validate: validatePluginName,
+        });
+      },
+      description: ({ results }) =>
+        p.text({
+          message: 'Description',
+          placeholder: `A BRIKA plugin for ${results.name}`,
+          defaultValue: `A BRIKA plugin for ${results.name}`,
+        }),
+      category: () =>
+        p.select({
+          message: 'What type of plugin is this?',
+          options: CATEGORIES.map((c) => ({
+            value: c.value,
+            label: c.label,
+            hint: c.hint,
+          })),
+          initialValue: 'action',
+        }),
+      author: () =>
+        p.text({
+          message: 'Author',
+          placeholder: gitUser || 'Your Name',
+          defaultValue: gitUser,
+        }),
+    },
+    {
+      onCancel: () => {
+        p.cancel('Operation cancelled.');
+        throw new Error('cancelled');
+      },
+    }
+  );
+
+  return {
+    name: answers.name as string,
+    description: answers.description as string,
+    category: answers.category as PluginConfig['category'],
+    author: answers.author as string,
+  };
+}

package/src/scaffold.ts

@@ -0,0 +1,188 @@
+/**
+ * Scaffold a new BRIKA plugin from file-based templates
+ */
+
+import * as p from '@clack/prompts';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import pc from 'picocolors';
+import type { PluginConfig } from './prompts';
+import { renderTemplate, runCommand, toCamelCase, toPascalCase } from './utils';
+
+export interface ScaffoldOptions extends PluginConfig {
+  git: boolean;
+  install: boolean;
+}
+
+/**
+ * Template variables available in all template files
+ */
+interface TemplateVars {
+  name: string;
+  packageName: string;
+  description: string;
+  category: string;
+  author: string;
+  blockId: string;
+  blockNamePascal: string;
+  blockNameCamel: string;
+  sdkVersion: string;
+}
+
+/**
+ * Fetch the latest version of a package from npm
+ */
+async function fetchLatestVersion(packageName: string): Promise<string> {
+  const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${packageName} version: ${response.status}`);
+  }
+  const data = (await response.json()) as { version: string };
+  return data.version;
+}
+
+/**
+ * File rename mappings (template name -> output name)
+ */
+const FILE_RENAMES: Record<string, string> = {
+  _gitignore: '.gitignore',
+  '_package.json': 'package.json',
+};
+
+/**
+ * Get output filename, handling .template extension
+ */
+function getOutputName(filename: string): string {
+  // Remove .template extension if present
+  if (filename.endsWith('.template')) {
+    filename = filename.slice(0, -'.template'.length);
+  }
+  // Apply rename mappings
+  return FILE_RENAMES[filename] ?? filename;
+}
+
+/**
+ * Create template variables from config
+ */
+function createTemplateVars(config: PluginConfig, sdkVersion: string): TemplateVars {
+  return {
+    name: config.name,
+    packageName: `@brika/plugin-${config.name}`,
+    description: config.description,
+    category: config.category,
+    author: config.author,
+    blockId: config.name,
+    blockNamePascal: toPascalCase(config.name),
+    blockNameCamel: toCamelCase(config.name),
+    sdkVersion,
+  };
+}
+
+/**
+ * Get the template directory path
+ */
+function getTemplateDir(): string {
+  return path.resolve(import.meta.dir, '..', 'template');
+}
+
+/**
+ * Process a single file: read, render, and write
+ */
+async function processFile(
+  srcPath: string,
+  destPath: string,
+  vars: Record<string, string>
+): Promise<void> {
+  const content = await fs.readFile(srcPath, 'utf-8');
+  const rendered = renderTemplate(content, vars);
+  await fs.writeFile(destPath, rendered, 'utf-8');
+}
+
+/**
+ * Recursively copy and render template files
+ */
+async function copyTemplateDir(
+  srcDir: string,
+  destDir: string,
+  vars: Record<string, string>
+): Promise<void> {
+  await fs.mkdir(destDir, { recursive: true });
+  const entries = await fs.readdir(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destName = getOutputName(entry.name);
+    const destPath = path.join(destDir, destName);
+
+    if (entry.isDirectory()) {
+      await copyTemplateDir(srcPath, destPath, vars);
+    } else {
+      await processFile(srcPath, destPath, vars);
+    }
+  }
+}
+
+/**
+ * Scaffold a new plugin
+ */
+export async function scaffold(options: ScaffoldOptions): Promise<void> {
+  const { git, install, ...config } = options;
+  const targetDir = path.resolve(process.cwd(), config.name);
+
+  // Check if directory exists
+  try {
+    await fs.access(targetDir);
+    p.cancel(`Directory ${pc.cyan(config.name)} already exists`);
+    throw new Error('cancelled');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  const templateDir = getTemplateDir();
+  const spinner = p.spinner();
+
+  // Fetch latest SDK version
+  spinner.start('Fetching latest SDK version');
+  const sdkVersion = await fetchLatestVersion('@brika/sdk');
+  spinner.stop(`Using SDK version ${pc.cyan(sdkVersion)}`);
+
+  const vars = createTemplateVars(config, sdkVersion) as unknown as Record<string, string>;
+
+  // Create files from template
+  spinner.start('Creating plugin files');
+  await copyTemplateDir(templateDir, targetDir, vars);
+  spinner.stop('Created plugin files');
+
+  // Initialize git repository
+  if (git) {
+    spinner.start('Initializing git repository');
+    const success = await runCommand(['git', 'init'], targetDir);
+    spinner.stop(success ? 'Initialized git repository' : 'Skipped git init');
+  }
+
+  // Install dependencies
+  if (install) {
+    spinner.start('Installing dependencies');
+    const success = await runCommand(['bun', 'install'], targetDir);
+    if (success) {
+      spinner.stop('Installed dependencies');
+    } else {
+      spinner.stop('Failed to install dependencies');
+      p.log.warn('Run `bun install` manually to install dependencies');
+    }
+  }
+
+  // Show summary
+  p.note(
+    [
+      `${pc.cyan('package.json')}     Plugin manifest with blocks`,
+      `${pc.cyan('src/index.ts')}     Block definitions`,
+      `${pc.cyan('tsconfig.json')}    TypeScript config`,
+      `${pc.cyan('README.md')}        Documentation`,
+      `${pc.cyan('locales/')}         i18n translations`,
+    ].join('\n'),
+    'Created files'
+  );
+}

package/src/utils.ts

@@ -0,0 +1,60 @@
+/**
+ * Utility functions for create-brika CLI
+ */
+
+/**
+ * Convert kebab-case to PascalCase
+ */
+export function toPascalCase(str: string): string {
+  return str
+    .split('-')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+}
+
+/**
+ * Convert kebab-case to camelCase
+ */
+export function toCamelCase(str: string): string {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+/**
+ * Render template string with variables using {{variable}} syntax
+ */
+export function renderTemplate(content: string, vars: Record<string, string>): string {
+  return content.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? '');
+}
+
+/**
+ * Get git user name
+ */
+export async function getGitUser(): Promise<string> {
+  try {
+    const proc = Bun.spawn(['git', 'config', 'user.name'], {
+      stdout: 'pipe',
+    });
+    const text = await new Response(proc.stdout).text();
+    return text.trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Run a command in a directory
+ */
+export async function runCommand(cmd: string[], cwd: string): Promise<boolean> {
+  try {
+    const proc = Bun.spawn(cmd, {
+      cwd,
+      stdout: 'ignore',
+      stderr: 'ignore',
+    });
+    await proc.exited;
+    return proc.exitCode === 0;
+  } catch {
+    return false;
+  }
+}

package/template/README.md

@@ -0,0 +1,48 @@
+# {{packageName}}
+
+{{description}}
+
+## Installation
+
+```bash
+bun add {{packageName}}
+```
+
+## Usage
+
+Add the plugin to your `brika.yml`:
+
+```yaml
+plugins:
+  "{{packageName}}":
+    enabled: true
+```
+
+## Blocks
+
+### {{blockNamePascal}}
+
+{{description}}
+
+**Inputs:**
+- `in` - Input data to process
+
+**Outputs:**
+- `out` - Processed output
+
+**Configuration:**
+- `enabled` (boolean) - Enable processing (default: true)
+
+## Development
+
+```bash
+# Link for local development
+bun link
+
+# Type check
+bun run tsc
+```
+
+## License
+
+MIT

package/template/_gitignore

@@ -0,0 +1,4 @@
+node_modules/
+dist/
+*.log
+.DS_Store

package/template/_package.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://schema.brika.dev/plugin.schema.json",
+  "name": "{{packageName}}",
+  "version": "0.1.0",
+  "description": "{{description}}",
+  "author": "{{author}}",
+  "keywords": [
+    "brika",
+    "plugin",
+    "{{name}}"
+  ],
+  "engines": {
+    "brika": "^{{sdkVersion}}"
+  },
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "link": "bun link",
+    "tsc": "bunx --bun tsc --noEmit"
+  },
+  "blocks": [
+    {
+      "id": "{{blockId}}",
+      "name": "{{blockNamePascal}}",
+      "description": "{{description}}",
+      "category": "{{category}}",
+      "icon": "box",
+      "color": "#3b82f6"
+    }
+  ],
+  "dependencies": {
+    "@brika/sdk": "^{{sdkVersion}}"
+  },
+  "devDependencies": {
+    "bun-types": "^1.3.5"
+  }
+}

package/template/locales/en/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "{{blockNamePascal}}",
+  "description": "{{description}}",
+  "blocks": {
+    "{{blockId}}": {
+      "name": "{{blockNamePascal}}",
+      "description": "{{description}}"
+    }
+  },
+  "fields": {
+    "enabled": {
+      "label": "Enabled",
+      "description": "Enable processing"
+    }
+  }
+}

package/template/src/index.ts.template

@@ -0,0 +1,57 @@
+/**
+ * {{blockNamePascal}} Plugin for BRIKA
+ *
+ * {{description}}
+ */
+
+import {
+  defineReactiveBlock,
+  input,
+  log,
+  onStop,
+  output,
+  z,
+} from "@brika/sdk";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// {{blockNamePascal}} Block
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const {{blockNameCamel}} = defineReactiveBlock(
+  {
+    id: "{{blockId}}",
+    inputs: {
+      in: input(z.generic(), { name: "Input" }),
+    },
+    outputs: {
+      out: output(z.passthrough("in"), { name: "Output" }),
+    },
+    config: z.object({
+      // Add your configuration options here
+      enabled: z.boolean().default(true).describe("Enable processing"),
+    }),
+  },
+  ({ inputs, outputs, config, log }) => {
+    inputs.in.on((data) => {
+      if (!config.enabled) {
+        log("debug", "Processing disabled, skipping");
+        return;
+      }
+
+      log("info", "Processing data", { data });
+
+      // TODO: Add your block logic here
+      outputs.out.emit(data);
+    });
+  }
+);
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Lifecycle
+// ─────────────────────────────────────────────────────────────────────────────
+
+onStop(() => {
+  log.info("{{blockNamePascal}} plugin stopping");
+});
+
+log.info("{{blockNamePascal}} plugin loaded");

package/template/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "composite": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src"]
+}