@silexlabs/silex 3.7.0 → 3.9.0-canary.2

package/grapesjs-plugins/grapesjs-ai-capabilities/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@silexlabs/grapesjs-ai-capabilities",
+  "version": "0.0.4",
+  "description": "Discovery and metadata layer for GrapesJS commands, enabling MCP tool exposure and external integrations",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/silexlabs/grapesjs-ai-capabilities.git"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "scripts": {
+    "start": "grapesjs-cli serve",
+    "build": "grapesjs-cli build --patch=false",
+    "lint": "eslint src",
+    "test": "node test/index.test.js"
+  },
+  "keywords": [
+    "silex",
+    "grapesjs",
+    "grapesjs-plugin",
+    "plugin",
+    "ai",
+    "mcp",
+    "capabilities"
+  ],
+  "devDependencies": {
+    "eslint": "^10.6.0",
+    "grapesjs-cli": "^4.1.3"
+  },
+  "peerDependencies": {
+    "grapesjs": ">=0.19.0 <0.23.0"
+  },
+  "author": {
+    "name": "Alex Hoyau",
+    "url": "https://lexoyo.me/"
+  },
+  "license": "GPL-3.0"
+}

package/grapesjs-plugins/grapesjs-ai-capabilities/src/index.js

@@ -0,0 +1,97 @@
+export const PLUGIN_ID = 'grapesjs-ai-capabilities'
+
+const registry = new Map()
+const OPTIONAL_FIELDS = ['title', 'tags', 'version', 'readOnly', 'destructive', 'idempotent', 'openWorld']
+
+function isPlainObject(v) {
+  if (v === null || typeof v !== 'object') return false
+  const proto = Object.getPrototypeOf(v)
+  return proto === Object.prototype || proto === null
+}
+
+export const EVENT_READY = 'ai-capabilities:ready'
+
+export default (editor) => {
+  // Expose registry for cross-module access (desktop-bridge, MCP server)
+  if (typeof window !== 'undefined') {
+    window.grapesjsAiCapabilities = {
+      addCapability,
+      getCapability,
+      getAllCapabilities,
+      removeCapability,
+      hasCapability,
+      clearCapabilities,
+    }
+  }
+  editor.on('load', () => {
+    editor.trigger(EVENT_READY, addCapability)
+  })
+}
+
+export function addCapability(def, options = {}) {
+  if (!def || typeof def.id !== 'string' || !def.id) {
+    throw new Error('id is required and must be a non-empty string')
+  }
+  if (typeof def.command !== 'string' || !def.command) {
+    throw new Error('command is required and must be a non-empty string')
+  }
+  const description = def.description || def.prompt
+  if (typeof description !== 'string' || !description) {
+    throw new Error('description (or prompt) is required and must be a non-empty string')
+  }
+  if (registry.has(def.id) && !options.replace) {
+    throw new Error(`Capability "${def.id}" already exists`)
+  }
+  if (def.tags !== undefined && !Array.isArray(def.tags)) {
+    throw new Error('tags must be an array')
+  }
+  if (def.inputSchema !== undefined && !isPlainObject(def.inputSchema)) {
+    throw new Error('inputSchema must be an object')
+  }
+  if (def.outputSchema !== undefined && !isPlainObject(def.outputSchema)) {
+    throw new Error('outputSchema must be an object')
+  }
+
+  const capability = {
+    id: def.id,
+    command: def.command,
+    description,
+    inputSchema: def.inputSchema || {},
+    outputSchema: def.outputSchema || {},
+  }
+  for (const field of OPTIONAL_FIELDS) {
+    if (def[field] !== undefined) capability[field] = def[field]
+  }
+  registry.set(def.id, capability)
+  return { ...capability }
+}
+
+export function getCapability(id) {
+  const cap = registry.get(id)
+  if (!cap) {
+    throw new Error(`Capability "${id}" not found`)
+  }
+  return { ...cap }
+}
+
+export function getAllCapabilities(filter = {}) {
+  let capabilities = Array.from(registry.values())
+  if (filter.tags && Array.isArray(filter.tags) && filter.tags.length) {
+    capabilities = capabilities.filter(c =>
+      c.tags && filter.tags.some(t => c.tags.includes(t))
+    )
+  }
+  return capabilities.map(c => ({ ...c }))
+}
+
+export function removeCapability(id) {
+  return registry.delete(id)
+}
+
+export function hasCapability(id) {
+  return registry.has(id)
+}
+
+export function clearCapabilities() {
+  registry.clear()
+}

package/grapesjs-plugins/grapesjs-ai-capabilities/test/index.test.js

@@ -0,0 +1,198 @@
+const assert = require('assert')
+const plugin = require('../dist/index.js')
+
+const {
+    addCapability,
+    getCapability,
+    getAllCapabilities,
+    removeCapability,
+    hasCapability,
+    clearCapabilities,
+    PLUGIN_ID,
+} = plugin
+
+function createEditor(commands = {}) {
+    const listeners = {}
+    return {
+        Commands: {
+            has(id) { return id in commands },
+        },
+        on(event, fn) { (listeners[event] = listeners[event] || []).push(fn) },
+        trigger(event, ...args) { (listeners[event] || []).forEach(fn => fn(...args)) },
+    }
+}
+
+function setup() {
+    clearCapabilities()
+    const editor = createEditor({ 'core:canvas-clear': true })
+    plugin.default(editor)
+    return editor
+}
+
+let passed = 0
+let total = 0
+
+function test(name, fn) {
+    total++
+    try {
+        fn()
+        passed++
+        console.log(`  PASS  ${name}`)
+    } catch (err) {
+        console.error(`  FAIL  ${name}`)
+        console.error(`        ${err.message}`)
+    }
+}
+
+console.log('grapesjs-ai-capabilities unit tests\n')
+
+test('PLUGIN_ID is exported', () => {
+    assert.strictEqual(PLUGIN_ID, 'grapesjs-ai-capabilities')
+})
+
+test('register and retrieve a capability', () => {
+    const editor = setup()
+    const cap = addCapability({
+        id: 'clear',
+        command: 'core:canvas-clear',
+        description: 'Clear the canvas',
+        tags: ['core'],
+        title: 'Clear',
+        version: '1.0',
+    })
+    assert.strictEqual(cap.id, 'clear')
+    assert.strictEqual(cap.title, 'Clear')
+
+    const get = getCapability('clear')
+    assert.strictEqual(get.description, 'Clear the canvas')
+})
+
+test('addCapability returns a copy', () => {
+    const editor = setup()
+    const cap = addCapability({ id: 'a', command: 'core:canvas-clear', description: 'd' })
+    cap.id = 'mutated'
+    assert.strictEqual(getCapability('a').id, 'a')
+})
+
+test('reject duplicate id', () => {
+    const editor = setup()
+    addCapability({ id: 'a', command: 'core:canvas-clear', description: 'd' })
+    assert.throws(
+        () => addCapability({ id: 'a', command: 'core:canvas-clear', description: 'd' }),
+        /already exists/
+    )
+})
+
+test('replace with option', () => {
+    const editor = setup()
+    addCapability({ id: 'a', command: 'core:canvas-clear', description: 'v1' })
+    const cap = addCapability({ id: 'a', command: 'core:canvas-clear', description: 'v2' }, { replace: true })
+    assert.strictEqual(cap.description, 'v2')
+})
+
+test('validation: missing id, command, description', () => {
+    const editor = setup()
+    assert.throws(() => addCapability({ command: 'x', description: 'y' }), /id/)
+    assert.throws(() => addCapability({ id: '', command: 'x', description: 'y' }), /id/)
+    assert.throws(() => addCapability({ id: 'a', description: 'y' }), /command/)
+    assert.throws(() => addCapability({ id: 'a', command: 'x' }), /description/)
+    assert.throws(() => addCapability(null))
+    assert.throws(() => addCapability(editor))
+})
+
+test('validation: tags, inputSchema, outputSchema types', () => {
+    const editor = setup()
+    assert.throws(() => addCapability({ id: 'a', command: 'x', description: 'y', tags: 'bad' }), /tags/)
+    assert.throws(() => addCapability({ id: 'a', command: 'x', description: 'y', inputSchema: 'bad' }), /inputSchema/)
+    assert.throws(() => addCapability({ id: 'a', command: 'x', description: 'y', outputSchema: [1] }), /outputSchema/)
+})
+
+test('prompt alias for description', () => {
+    const editor = setup()
+    const cap = addCapability({ id: 'p', command: 'core:canvas-clear', prompt: 'Do something' })
+    assert.strictEqual(cap.description, 'Do something')
+})
+
+test('optional fields omitted when not provided', () => {
+    const editor = setup()
+    const cap = addCapability({ id: 'min', command: 'core:canvas-clear', description: 'd' })
+    assert.strictEqual(cap.title, undefined)
+    assert.strictEqual(cap.tags, undefined)
+    assert.strictEqual(cap.version, undefined)
+})
+
+test('getCapability returns copy', () => {
+    const editor = setup()
+    addCapability({ id: 'a', command: 'core:canvas-clear', description: 'd' })
+    const r = getCapability('a')
+    r.id = 'mutated'
+    assert.strictEqual(getCapability('a').id, 'a')
+})
+
+test('getCapability missing throws', () => {
+    setup()
+    assert.throws(() => getCapability('nope'), /not found/)
+})
+
+test('getAllCapabilities returns all in order', () => {
+    const editor = setup()
+    addCapability({ id: 'a', command: 'core:canvas-clear', description: 'd1' })
+    addCapability({ id: 'b', command: 'core:canvas-clear', description: 'd2' })
+    const caps = getAllCapabilities()
+    assert.strictEqual(caps.length, 2)
+    assert.strictEqual(caps[0].id, 'a')
+    assert.strictEqual(caps[1].id, 'b')
+})
+
+test('getAllCapabilities returns copies and is JSON-serializable', () => {
+    const editor = setup()
+    addCapability({ id: 'a', command: 'core:canvas-clear', description: 'd' })
+    const caps = getAllCapabilities()
+    caps[0].id = 'mutated'
+    assert.strictEqual(getAllCapabilities()[0].id, 'a')
+    JSON.parse(JSON.stringify(caps))
+})
+
+test('getAllCapabilities filter by tags', () => {
+    const editor = setup()
+    addCapability({ id: 'a', command: 'core:canvas-clear', description: 'd', tags: ['ui'] })
+    addCapability({ id: 'b', command: 'core:canvas-clear', description: 'd', tags: ['data'] })
+    assert.strictEqual(getAllCapabilities({ tags: ['ui'] }).length, 1)
+    assert.strictEqual(getAllCapabilities({ tags: ['nope'] }).length, 0)
+    assert.strictEqual(getAllCapabilities({}).length, 2)
+})
+
+test('removeCapability', () => {
+    const editor = setup()
+    addCapability({ id: 'x', command: 'core:canvas-clear', description: 'd' })
+    assert.strictEqual(removeCapability('x'), true)
+    assert.strictEqual(removeCapability('x'), false)
+    assert.strictEqual(getAllCapabilities().length, 0)
+})
+
+test('hasCapability', () => {
+    const editor = setup()
+    addCapability({ id: 'h', command: 'core:canvas-clear', description: 'd' })
+    assert.strictEqual(hasCapability('h'), true)
+    assert.strictEqual(hasCapability('nope'), false)
+})
+
+test('late-binding warns but succeeds', () => {
+    const editor = setup()
+    const cap = addCapability({ id: 'late', command: 'future:cmd', description: 'd' })
+    assert.strictEqual(cap.id, 'late')
+})
+
+test('triggers ai-capabilities:ready on load with addCapability', () => {
+    const editor = setup()
+    let received = null
+    editor.on('ai-capabilities:ready', (fn) => { received = fn })
+    editor.trigger('load')
+    assert.strictEqual(typeof received, 'function')
+    const cap = received({ id: 'via-event', command: 'core:canvas-clear', description: 'd' })
+    assert.strictEqual(cap.id, 'via-event')
+    assert.strictEqual(getCapability('via-event').id, 'via-event')
+})
+
+console.log(`\n${passed}/${total} passed, ${total - passed} failed`)
+process.exit(passed === total ? 0 : 1)

package/grapesjs-plugins/grapesjs-ai-capabilities/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "es2019",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": false,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist"
+  },
+  "include": [
+    "src"
+  ]
+}

package/grapesjs-plugins/grapesjs-css-variables/.eslintrc.json

@@ -0,0 +1,31 @@
+{
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "extends": "eslint:recommended",
+    "overrides": [
+    ],
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "rules": {
+        "indent": [
+            "error",
+            2
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "never"
+        ]
+    }
+}