@backbay/glia 0.2.0-alpha.1

package/dist/workspace/validation.js

@@ -0,0 +1,331 @@
+/**
+ * WorkspaceSpec Validation
+ *
+ * Validates workspace specifications and provides helpful error messages.
+ */
+import { getRegistry } from "./registry/index.js";
+/**
+ * Validate a WorkspaceSpec
+ */
+export function validateWorkspace(spec) {
+    const errors = [];
+    const warnings = [];
+    const registry = getRegistry();
+    // Validate required fields
+    if (!spec.id) {
+        errors.push({
+            path: "id",
+            message: "Workspace ID is required",
+            code: "MISSING_ID",
+        });
+    }
+    if (!spec.name) {
+        errors.push({
+            path: "name",
+            message: "Workspace name is required",
+            code: "MISSING_NAME",
+        });
+    }
+    if (!spec.layout) {
+        errors.push({
+            path: "layout",
+            message: "Workspace layout is required",
+            code: "MISSING_LAYOUT",
+        });
+    }
+    else {
+        // Validate layout recursively
+        validateLayoutNode(spec.layout, "layout", errors, warnings, registry);
+    }
+    // Validate bindings
+    if (spec.bindings) {
+        spec.bindings.forEach((binding, i) => {
+            if (!binding.source) {
+                errors.push({
+                    path: `bindings[${i}].source`,
+                    message: "Binding source is required",
+                    code: "MISSING_BINDING_SOURCE",
+                });
+            }
+            if (!binding.event) {
+                errors.push({
+                    path: `bindings[${i}].event`,
+                    message: "Binding event is required",
+                    code: "MISSING_BINDING_EVENT",
+                });
+            }
+            if (!binding.action) {
+                errors.push({
+                    path: `bindings[${i}].action`,
+                    message: "Binding action is required",
+                    code: "MISSING_BINDING_ACTION",
+                });
+            }
+        });
+    }
+    // Validate state
+    if (spec.state?.persist && !spec.state.persist.key) {
+        errors.push({
+            path: "state.persist.key",
+            message: "Persistence key is required when persist is enabled",
+            code: "MISSING_PERSIST_KEY",
+        });
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validate a layout node recursively
+ */
+function validateLayoutNode(node, path, errors, warnings, registry) {
+    if (!node.type) {
+        errors.push({
+            path,
+            message: "Layout node type is required",
+            code: "MISSING_NODE_TYPE",
+        });
+        return;
+    }
+    switch (node.type) {
+        case "split":
+            if (!node.children || node.children.length < 2) {
+                errors.push({
+                    path: `${path}.children`,
+                    message: "Split layout requires at least 2 children",
+                    code: "SPLIT_MIN_CHILDREN",
+                });
+            }
+            else {
+                node.children.forEach((child, i) => {
+                    validateLayoutNode(child, `${path}.children[${i}]`, errors, warnings, registry);
+                });
+            }
+            break;
+        case "stack":
+            if (!node.children || node.children.length === 0) {
+                warnings.push({
+                    path: `${path}.children`,
+                    message: "Stack layout has no children",
+                    suggestion: "Add child nodes or use a placeholder",
+                });
+            }
+            else {
+                node.children.forEach((child, i) => {
+                    validateLayoutNode(child, `${path}.children[${i}]`, errors, warnings, registry);
+                });
+            }
+            break;
+        case "tabs":
+            if (!node.children || node.children.length === 0) {
+                errors.push({
+                    path: `${path}.children`,
+                    message: "Tabs layout requires at least one tab",
+                    code: "TABS_MIN_CHILDREN",
+                });
+            }
+            else {
+                const tabIds = new Set();
+                node.children.forEach((tab, i) => {
+                    if (!tab.id) {
+                        errors.push({
+                            path: `${path}.children[${i}].id`,
+                            message: "Tab ID is required",
+                            code: "MISSING_TAB_ID",
+                        });
+                    }
+                    else if (tabIds.has(tab.id)) {
+                        errors.push({
+                            path: `${path}.children[${i}].id`,
+                            message: `Duplicate tab ID: ${tab.id}`,
+                            code: "DUPLICATE_TAB_ID",
+                        });
+                    }
+                    else {
+                        tabIds.add(tab.id);
+                    }
+                    if (!tab.label) {
+                        warnings.push({
+                            path: `${path}.children[${i}].label`,
+                            message: "Tab label is missing",
+                            suggestion: "Add a label for accessibility",
+                        });
+                    }
+                    if (tab.content) {
+                        validateLayoutNode(tab.content, `${path}.children[${i}].content`, errors, warnings, registry);
+                    }
+                    else {
+                        errors.push({
+                            path: `${path}.children[${i}].content`,
+                            message: "Tab content is required",
+                            code: "MISSING_TAB_CONTENT",
+                        });
+                    }
+                });
+                // Validate defaultTab
+                if (node.defaultTab && !tabIds.has(node.defaultTab)) {
+                    errors.push({
+                        path: `${path}.defaultTab`,
+                        message: `Default tab "${node.defaultTab}" not found`,
+                        code: "INVALID_DEFAULT_TAB",
+                    });
+                }
+            }
+            break;
+        case "grid":
+            if (!node.children || node.children.length === 0) {
+                warnings.push({
+                    path: `${path}.children`,
+                    message: "Grid layout has no items",
+                    suggestion: "Add grid items",
+                });
+            }
+            else {
+                node.children.forEach((item, i) => {
+                    if (item.content) {
+                        validateLayoutNode(item.content, `${path}.children[${i}].content`, errors, warnings, registry);
+                    }
+                    else {
+                        errors.push({
+                            path: `${path}.children[${i}].content`,
+                            message: "Grid item content is required",
+                            code: "MISSING_GRID_CONTENT",
+                        });
+                    }
+                });
+            }
+            break;
+        case "panel":
+            validatePanelNode(node, path, errors, warnings, registry);
+            break;
+        case "slot":
+            if (!node.name) {
+                errors.push({
+                    path: `${path}.name`,
+                    message: "Slot name is required",
+                    code: "MISSING_SLOT_NAME",
+                });
+            }
+            if (node.fallback) {
+                validateLayoutNode(node.fallback, `${path}.fallback`, errors, warnings, registry);
+            }
+            break;
+        default:
+            errors.push({
+                path: `${path}.type`,
+                message: `Unknown layout type: ${node.type}`,
+                code: "UNKNOWN_NODE_TYPE",
+            });
+    }
+}
+/**
+ * Validate a panel node
+ */
+function validatePanelNode(node, path, errors, warnings, registry) {
+    if (!node.component) {
+        errors.push({
+            path: `${path}.component`,
+            message: "Panel component ID is required",
+            code: "MISSING_COMPONENT",
+        });
+        return;
+    }
+    // Check if component exists in registry
+    const manifest = registry.get(node.component);
+    if (!manifest) {
+        warnings.push({
+            path: `${path}.component`,
+            message: `Component "${node.component}" not found in registry`,
+            suggestion: "Check component ID or register the component",
+        });
+        return;
+    }
+    // Validate required props
+    if (manifest.props) {
+        Object.entries(manifest.props).forEach(([propName, propSchema]) => {
+            if (propSchema.required && !(node.props && propName in node.props)) {
+                errors.push({
+                    path: `${path}.props.${propName}`,
+                    message: `Required prop "${propName}" is missing for ${node.component}`,
+                    code: "MISSING_REQUIRED_PROP",
+                });
+            }
+        });
+    }
+    // Validate prop types (basic)
+    if (node.props && manifest.props) {
+        Object.entries(node.props).forEach(([propName, propValue]) => {
+            const propSchema = manifest.props[propName];
+            if (!propSchema) {
+                warnings.push({
+                    path: `${path}.props.${propName}`,
+                    message: `Unknown prop "${propName}" for ${node.component}`,
+                    suggestion: "Check prop name or remove it",
+                });
+            }
+            else if (propSchema.enum && !propSchema.enum.includes(String(propValue))) {
+                errors.push({
+                    path: `${path}.props.${propName}`,
+                    message: `Invalid value "${propValue}" for ${propName}. Expected one of: ${propSchema.enum.join(", ")}`,
+                    code: "INVALID_ENUM_VALUE",
+                });
+            }
+        });
+    }
+    // Validate children composition
+    if (node.children && node.children.length > 0) {
+        if (!manifest.slots || manifest.slots.length === 0) {
+            warnings.push({
+                path: `${path}.children`,
+                message: `Component "${node.component}" does not define slots but has children`,
+                suggestion: "Check if this component supports children",
+            });
+        }
+        node.children.forEach((child, i) => {
+            validatePanelNode(child, `${path}.children[${i}]`, errors, warnings, registry);
+            // Check composition validity
+            const childManifest = registry.get(child.component);
+            if (childManifest && !registry.canCompose(node.component, child.component)) {
+                warnings.push({
+                    path: `${path}.children[${i}]`,
+                    message: `"${child.component}" may not be valid inside "${node.component}"`,
+                    suggestion: "Check component composition rules",
+                });
+            }
+        });
+    }
+}
+/**
+ * Quick validation check (returns boolean only)
+ */
+export function isValidWorkspace(spec) {
+    return validateWorkspace(spec).valid;
+}
+/**
+ * Extract all component IDs used in a workspace
+ */
+export function extractComponentIds(spec) {
+    const ids = new Set();
+    function extractFromNode(node) {
+        if (node.type === "panel") {
+            ids.add(node.component);
+            node.children?.forEach(extractFromNode);
+        }
+        else if (node.type === "split" || node.type === "stack") {
+            node.children.forEach(extractFromNode);
+        }
+        else if (node.type === "tabs") {
+            node.children.forEach((tab) => extractFromNode(tab.content));
+        }
+        else if (node.type === "grid") {
+            node.children.forEach((item) => extractFromNode(item.content));
+        }
+        else if (node.type === "slot" && node.fallback) {
+            extractFromNode(node.fallback);
+        }
+    }
+    extractFromNode(spec.layout);
+    return Array.from(ids);
+}

package/package.json

@@ -0,0 +1,172 @@
+{
+  "name": "@backbay/glia",
+  "version": "0.2.0-alpha.1",
+  "description": "Reactive primitives for agent affect and thought",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "homepage": "https://github.com/backbay/glia#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/backbay/glia.git"
+  },
+  "bugs": {
+    "url": "https://github.com/backbay/glia/issues"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js"
+    },
+    "./protocol": {
+      "types": "./dist/protocol/index.d.ts",
+      "import": "./dist/protocol/index.js"
+    },
+    "./hooks": {
+      "types": "./dist/hooks/index.d.ts",
+      "import": "./dist/hooks/index.js"
+    },
+    "./speakeasy": {
+      "types": "./dist/speakeasy/index.d.ts",
+      "import": "./dist/speakeasy/index.js"
+    },
+    "./components": {
+      "types": "./dist/components/index.d.ts",
+      "import": "./dist/components/index.js"
+    },
+    "./workspace": {
+      "types": "./dist/workspace/index.d.ts",
+      "import": "./dist/workspace/index.js"
+    },
+    "./primitives": {
+      "types": "./dist/primitives/index.d.ts",
+      "import": "./dist/primitives/index.js"
+    },
+    "./theme": {
+      "types": "./dist/theme/index.d.ts",
+      "import": "./dist/theme/index.js"
+    },
+    "./emotion": {
+      "types": "./dist/emotion/index.d.ts",
+      "import": "./dist/emotion/index.js"
+    },
+    "./vision": {
+      "types": "./dist/vision/index.d.ts",
+      "import": "./dist/vision/index.js"
+    },
+    "./audio": {
+      "types": "./dist/audio/index.d.ts",
+      "import": "./dist/audio/index.js"
+    },
+    "./cognition": {
+      "types": "./dist/cognition/index.d.ts",
+      "import": "./dist/cognition/index.js"
+    },
+    "./desktop": {
+      "types": "./dist/desktop/index.d.ts",
+      "import": "./dist/desktop/index.js"
+    },
+    "./desktop/core": {
+      "types": "./dist/desktop/core/index.d.ts",
+      "import": "./dist/desktop/core/index.js"
+    },
+    "./desktop/themes": {
+      "types": "./dist/desktop/themes/index.d.ts",
+      "import": "./dist/desktop/themes/index.js"
+    },
+    "./styles": "./dist/styles.css",
+    "./styles.css": "./dist/styles.css"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "style": "./dist/styles.css",
+  "scripts": {
+    "build": "bunx tsc || true; bunx tailwindcss -c tailwind.config.js -i src/styles/globals.css -o dist/styles.css --minify",
+    "test": "node scripts/vitest.mjs run --config vitest.config.mjs",
+    "test:watch": "node scripts/vitest.mjs --config vitest.config.mjs",
+    "typecheck": "bunx tsc --noEmit",
+    "storybook": "node scripts/storybook.mjs dev -p 6006",
+    "build-storybook": "node scripts/storybook.mjs build"
+  },
+  "dependencies": {
+    "@backbay/contract": "0.1.0-alpha.1",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^3.4.0",
+    "zod": "^3.23.0",
+    "zustand": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "optionalDependencies": {
+    "@radix-ui/react-alert-dialog": "^1.1.15",
+    "@radix-ui/react-avatar": "^1.1.11",
+    "@radix-ui/react-dialog": "^1.1.15",
+    "@radix-ui/react-dropdown-menu": "^2.1.16",
+    "@radix-ui/react-icons": "^1.3.2",
+    "@radix-ui/react-label": "^2.1.8",
+    "@radix-ui/react-popover": "^1.1.15",
+    "@radix-ui/react-scroll-area": "^1.2.10",
+    "@radix-ui/react-select": "^2.2.6",
+    "@radix-ui/react-separator": "^1.1.8",
+    "@radix-ui/react-slot": "^1.2.4",
+    "@radix-ui/react-switch": "^1.2.6",
+    "@radix-ui/react-tabs": "^1.1.13",
+    "@radix-ui/react-toggle": "^1.1.10",
+    "@radix-ui/react-tooltip": "^1.2.8",
+    "framer-motion": "^12.23.24",
+    "react-rnd": "^10.4.13",
+    "lucide-react": "^0.555.0",
+    "cmdk": "^1.1.1",
+    "sonner": "^2.0.7",
+    "three": "0.179.1",
+    "@react-three/fiber": "9.4.2",
+    "@react-three/drei": "10.7.7"
+  },
+  "devDependencies": {
+    "@storybook/cli": "^10.1.11",
+    "@storybook/react": "^10.1.11",
+    "@storybook/react-vite": "^10.1.11",
+    "@testing-library/react": "^16.0.0",
+    "@types/bun": "latest",
+    "@types/react": "^19.0.0",
+    "@types/three": "^0.170.0",
+    "@vitejs/plugin-react": "^5.1.2",
+    "autoprefixer": "^10.4.20",
+    "happy-dom": "^15.0.0",
+    "postcss": "^8.4.49",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "storybook": "^10.1.11",
+    "tailwindcss": "^3.4.17",
+    "typescript": "^5.9.2",
+    "vite": "^7.3.1",
+    "vitest": "^2.0.0"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "web",
+    "ui",
+    "protocol",
+    "llm",
+    "cua",
+    "workspace",
+    "registry",
+    "components"
+  ],
+  "license": "MIT"
+}