@dimescheduler/setup 0.1.0

package/README.md

@@ -0,0 +1,404 @@
+# @dimescheduler/setup
+
+CLI tool to validate, compile, and deploy Dime Scheduler configurations.
+
+## Installation
+
+```bash
+npm install -g @dimescheduler/setup
+```
+
+Or use with npx:
+
+```bash
+npx @dimescheduler/setup <command>
+```
+
+## Commands
+
+### `validate`
+
+Validate a configuration file against the Dime Scheduler DSL schema.
+
+```bash
+dimescheduler-setup validate <file>
+```
+
+**Arguments:**
+- `<file>` - Path to the configuration file (.json5 or .json)
+
+**Options:**
+- `--json` - Output results as JSON
+
+**Examples:**
+
+```bash
+# Validate a configuration file
+dimescheduler-setup validate my-profile.json5
+
+# Get validation results as JSON (useful for CI/CD)
+dimescheduler-setup validate my-profile.json5 --json
+```
+
+**Exit codes:**
+- `0` - Configuration is valid
+- `1` - Configuration has errors
+
+---
+
+### `compile`
+
+Compile a JSON5 configuration to API-ready JSON format.
+
+```bash
+dimescheduler-setup compile <file> [options]
+```
+
+**Arguments:**
+- `<file>` - Path to the configuration file (.json5)
+
+**Options:**
+- `-o, --output <dir>` - Output directory (default: same as input file)
+- `--stdout` - Output to stdout instead of writing to a file
+- `--skip-validation` - Skip validation before compiling
+
+**Examples:**
+
+```bash
+# Compile to JSON (creates my-profile.json in the same directory)
+dimescheduler-setup compile my-profile.json5
+
+# Compile to a specific directory
+dimescheduler-setup compile my-profile.json5 -o ./dist
+
+# Output to stdout (useful for piping)
+dimescheduler-setup compile my-profile.json5 --stdout
+
+# Skip validation (not recommended)
+dimescheduler-setup compile my-profile.json5 --skip-validation
+```
+
+---
+
+### `deploy`
+
+Deploy a configuration directly to a Dime Scheduler instance.
+
+```bash
+dimescheduler-setup deploy <file> --api-key <key> --env <environment> [options]
+```
+
+**Arguments:**
+- `<file>` - Path to the configuration file (.json5 or .json)
+
+**Options:**
+- `--api-key <key>` - API key for authentication (required, or set `DS_API_KEY` env var)
+- `--env <environment>` - Environment: `production`, `sandbox`, or `test` (required)
+- `--skip-validation` - Skip validation before deploying
+- `--json` - Output results as JSON
+- `--dry-run` - Validate and compile without actually deploying
+- `-y, --yes` - Skip confirmation prompt
+
+**Examples:**
+
+```bash
+# Deploy to sandbox (shows confirmation prompt)
+dimescheduler-setup deploy my-profile.json5 --api-key YOUR_API_KEY --env sandbox
+
+# Deploy to production with confirmation
+dimescheduler-setup deploy my-profile.json5 --api-key YOUR_API_KEY --env production
+
+# Skip confirmation prompt (for CI/CD)
+dimescheduler-setup deploy my-profile.json5 --api-key YOUR_API_KEY --env sandbox -y
+
+# Use environment variable for API key
+export DS_API_KEY=YOUR_API_KEY
+dimescheduler-setup deploy my-profile.json5 --env sandbox
+
+# Dry run (validate and compile only)
+dimescheduler-setup deploy my-profile.json5 --api-key YOUR_API_KEY --env sandbox --dry-run
+
+# Get results as JSON (useful for CI/CD, skips confirmation)
+dimescheduler-setup deploy my-profile.json5 --api-key YOUR_API_KEY --env sandbox --json
+```
+
+**Exit codes:**
+- `0` - Deployment successful (or cancelled by user)
+- `1` - Validation or compilation error
+- `2` - Deployment failed (API error)
+
+## Configuration Format
+
+Configuration files use [JSON5](https://json5.org/) format, which supports:
+- Comments (`//` and `/* */`)
+- Trailing commas
+- Unquoted keys
+- Single-quoted strings
+
+### Example Configuration
+
+```json5
+{
+  name: "Service Planning",
+  code: "SERVICE_PLANNING",
+
+  // Optional metadata
+  owner: "admin@example.com",
+  notificationEmail: "notifications@example.com",
+
+  // Visual theme
+  theme: {
+    color: "blue",
+    scheme: "sltl"
+  },
+
+  // Sharing settings
+  shared: {
+    global: false,
+    userGroup: "Planners"
+  },
+
+  // Route calculation settings
+  route: {
+    profile: "default",
+    calculateRoutes: true,
+    showSequenceIndicators: true,
+    unitOfDistance: "km"  // or "mi"
+  },
+
+  // Planning board settings
+  planning: {
+    snapInterval: { mode: "1hour" },  // or "15min", "30min", "day", or 1-10
+    range: { mode: "week" },          // or "day", "month", "year"
+    start: { mode: "today" },         // or "yesterday", "week", "month"
+    hours: { start: 8, end: 18 }
+  },
+
+  // Workspace layout (GoldenLayout structure)
+  workspace: [
+    {
+      type: "row",
+      content: [
+        {
+          type: "column",
+          width: 30,
+          content: [
+            {
+              type: "stack",
+              content: [
+                {
+                  type: "component",
+                  component: "openTasks",
+                  title: "Open Tasks",
+                  id: "openTasks1",
+                  layouts: [{
+                    id: "openTasks1",
+                    code: "OPEN_TASKS",
+                    name: "Default",
+                    default: true,
+                    columns: [
+                      { property: "Job.JobNo" },
+                      { property: "TaskNo" }
+                    ],
+                    sorters: [
+                      { property: "Job.JobNo", direction: "ASC" }
+                    ]
+                  }]
+                }
+              ]
+            }
+          ]
+        },
+        {
+          type: "column",
+          width: 70,
+          content: [
+            {
+              type: "stack",
+              content: [
+                {
+                  type: "component",
+                  component: "planningBoard",
+                  title: "Planning Board",
+                  layouts: [{
+                    id: "planningBoard1",
+                    code: "SCHEDULER",
+                    name: "Default View",
+                    default: true,
+                    viewPreset: "week",
+                    columns: [
+                      { property: "DisplayName" },
+                      { property: "Department" }
+                    ],
+                    grouper: {
+                      property: "ResourceType.DisplayName",
+                      direction: "ASC",
+                      id: "ResourceType.DisplayName"
+                    }
+                  }]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ],
+
+  // Optional: User definitions
+  users: [
+    {
+      name: "John Doe",
+      email: "john@example.com",
+      language: "en",
+      timeZone: "America/New_York",
+      profiles: [{ name: "SERVICE_PLANNING", default: true }],
+      roles: ["Administrator"],
+      timeMarkers: ["IN PROCESS"],
+      categories: ["HARDWARE"],
+      filterValues: ["East"]
+    }
+  ]
+}
+```
+
+### Available Components
+
+| Component | Description |
+|-----------|-------------|
+| `openTasks` | Grid showing unplanned tasks |
+| `planningBoard` | Main scheduling board |
+| `mapComponent` | Map view |
+| `indicators` | Category indicators |
+| `resourceFilters` | Resource filter panel |
+| `plannedTasksGridComponent` | Grid showing planned tasks |
+| `propertygridComponent` | Details/properties panel |
+| `datePickerComponent` | Calendar date picker |
+| `ganttComponent` | Gantt chart view |
+| `capacityComponent` | Capacity planning view |
+| `routeSequenceComponent` | Route sequence grid |
+| `notificationsComponent` | Notifications panel |
+
+### Layout Configuration
+
+Components can include `layouts` for configuring grid columns, sorting, filtering, and grouping:
+
+```json5
+layouts: [{
+  id: "myGrid1",
+  code: "MY_LAYOUT",
+  name: "My Custom Layout",
+  default: true,
+
+  // Column configuration
+  columns: [
+    { property: "Job.JobNo", width: 100 },
+    { property: "Description" }
+  ],
+
+  // Sorting
+  sorters: [
+    { property: "Job.JobNo", direction: "ASC" },
+    { property: "TaskNo", direction: "DESC" }
+  ],
+
+  // Filtering
+  filters: [
+    { property: "Status", operator: "eq", value: "Active" }
+  ],
+
+  // Grouping
+  grouper: {
+    property: "Category",
+    direction: "ASC",
+    id: "Category"
+  },
+
+  // Grid settings
+  pageSize: 50,
+  rowHeight: "2rows",  // "1row", "2rows", "3rows", "4rows", or pixel value
+  viewPreset: "week",  // "day", "week", "workWeek", "month"
+  lockedGridWidth: "30%",
+  fitToScreen: false,
+
+  // Sharing (optional)
+  shared: {
+    public: true,
+    userGroup: "Planners"
+  }
+}]
+```
+
+## CI/CD Integration
+
+### GitHub Actions Example
+
+```yaml
+name: Deploy Configuration
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'configs/*.json5'
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install CLI
+        run: npm install -g @dimescheduler/setup
+
+      - name: Validate
+        run: dimescheduler-setup validate configs/my-profile.json5
+
+      - name: Deploy
+        run: dimescheduler-setup deploy configs/my-profile.json5 --env sandbox --json
+        env:
+          DS_API_KEY: ${{ secrets.DS_API_KEY }}
+```
+
+### Azure DevOps Example
+
+```yaml
+trigger:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - configs/*.json5
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+steps:
+  - task: NodeTool@0
+    inputs:
+      versionSpec: '20.x'
+
+  - script: npm install -g @dimescheduler/setup
+    displayName: 'Install CLI'
+
+  - script: dimescheduler-setup validate configs/my-profile.json5
+    displayName: 'Validate Configuration'
+
+  - script: dimescheduler-setup deploy configs/my-profile.json5 --env sandbox -y
+    displayName: 'Deploy Configuration'
+    env:
+      DS_API_KEY: $(DS_API_KEY)
+```
+
+## Requirements
+
+- Node.js 18 or higher
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,732 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command4 } from "commander";
+
+// src/commands/validate.ts
+import { Command } from "commander";
+import { readFileSync } from "fs";
+import { resolve, normalize } from "path";
+import JSON5 from "json5";
+import pc from "picocolors";
+
+// src/core/validate.ts
+function countComponents(nodes) {
+  let count = 0;
+  for (const node of nodes) {
+    if (node.type === "component") {
+      count++;
+    } else if ("content" in node) {
+      count += countComponents(node.content);
+    }
+  }
+  return count;
+}
+function hasComponent(nodes, componentType) {
+  for (const node of nodes) {
+    if (node.type === "component" && node.component === componentType) {
+      return true;
+    } else if ("content" in node) {
+      if (hasComponent(node.content, componentType)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function validateProfile(profile) {
+  const issues = [];
+  if (!profile.name?.trim()) {
+    issues.push({ type: "error", message: "Profile name is required" });
+  }
+  if (!profile.code?.trim()) {
+    issues.push({ type: "error", message: "Profile code is required" });
+  }
+  if (!profile.workspace || profile.workspace.length === 0) {
+    issues.push({ type: "error", message: "Workspace must have at least one element" });
+  } else {
+    const componentCount = countComponents(profile.workspace);
+    if (componentCount === 0) {
+      issues.push({ type: "warning", message: "Workspace has no components" });
+    }
+    const hasPlanningBoard = hasComponent(profile.workspace, "planningBoard");
+    if (!hasPlanningBoard) {
+      issues.push({ type: "warning", message: "Consider adding a Planning Board component" });
+    }
+  }
+  if (profile.users && profile.users.length > 0) {
+    profile.users.forEach((user, index) => {
+      if (!user.name?.trim()) {
+        issues.push({ type: "error", message: `User ${index + 1}: Name is required` });
+      }
+      if (!user.email?.trim()) {
+        issues.push({ type: "error", message: `User ${index + 1}: Email is required` });
+      }
+    });
+  }
+  const errors = issues.filter((i) => i.type === "error");
+  const warnings = issues.filter((i) => i.type === "warning");
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+// src/core/compile.ts
+var SNAP_MODE_MAP = {
+  "none": 1,
+  "off": 1,
+  "5min": 2,
+  "5minutes": 2,
+  "10min": 3,
+  "10minutes": 3,
+  "15min": 4,
+  "15minutes": 4,
+  "30min": 5,
+  "30minutes": 5,
+  "halfhour": 5,
+  "1hour": 6,
+  "1h": 6,
+  "hour": 6,
+  "12hours": 7,
+  "12h": 7,
+  "1day": 8,
+  "1d": 8,
+  "day": 8,
+  "2hours": 9,
+  "2h": 9,
+  "4hours": 10,
+  "4h": 10
+};
+var RANGE_MODE_MAP = {
+  "day": 1,
+  "days": 1,
+  "hours": 1,
+  "week": 2,
+  "weeks": 2,
+  "month": 3,
+  "months": 3,
+  "custom": 4
+};
+var START_MODE_MAP = {
+  "today": 1,
+  "absolute": 1,
+  "startofweek": 2,
+  "relative": 2,
+  "startofmonth": 3,
+  "todayoffset": 4
+};
+var COMPONENT_TO_GL = {
+  "openTasks": "openTasksGridComponent",
+  "planningBoard": "schedulerComponent",
+  "mapComponent": "mapComponent",
+  "indicators": "categoriesComponent",
+  "resourceFilters": "filterComponent",
+  "plannedTasksGridComponent": "plannedTasksGridComponent",
+  "propertygridComponent": "propertygridComponent",
+  "datePickerComponent": "datePickerComponent",
+  "ganttComponent": "ganttComponent",
+  "capacityComponent": "capacityComponent",
+  "routeSequenceComponent": "routeSequenceComponent",
+  "notificationsComponent": "notificationsComponent"
+};
+var COMPONENT_TO_CONTEXT = {
+  "planningBoard": "scheduler",
+  "openTasks": "unplannedTasksGrid",
+  "plannedTasksGridComponent": "plannedTasksGrid",
+  "notificationsComponent": "notificationsGrid",
+  "propertygridComponent": "detailsGrid",
+  "capacityComponent": "pivotGrid",
+  "ganttComponent": "gantt",
+  "routeSequenceComponent": "routeSequenceGrid"
+};
+var VIEW_PRESET_MAP = {
+  "day": "1",
+  "1": "1",
+  "week": "2",
+  "2": "2",
+  "workweek": "3",
+  "workWeek": "3",
+  "work_week": "3",
+  "3": "3",
+  "month": "4",
+  "4": "4"
+};
+var ROW_HEIGHT_MAP = {
+  "1row": 25,
+  "1rows": 25,
+  "1": 25,
+  "25": 25,
+  "2rows": 38,
+  "2row": 38,
+  "2": 38,
+  "38": 38,
+  "3rows": 50,
+  "3row": 50,
+  "3": 50,
+  "50": 50,
+  "4rows": 63,
+  "4row": 63,
+  "4": 63,
+  "63": 63
+};
+function mapSnapMode(mode) {
+  if (!mode) return 6;
+  return SNAP_MODE_MAP[mode.toLowerCase()] ?? 6;
+}
+function mapRangeMode(mode) {
+  if (!mode) return 2;
+  return RANGE_MODE_MAP[mode.toLowerCase()] ?? 2;
+}
+function mapStartMode(mode) {
+  if (!mode) return 2;
+  return START_MODE_MAP[mode.toLowerCase().replace(/\s+/g, "")] ?? 2;
+}
+function mapUnitOfDistance(unit) {
+  if (!unit) return "Kilometers";
+  const v = unit.toLowerCase();
+  if (["km", "kilometer", "kilometers"].includes(v)) return "Kilometers";
+  if (["mi", "mile", "miles"].includes(v)) return "Miles";
+  return unit;
+}
+function componentToGlName(name) {
+  return COMPONENT_TO_GL[name] ?? name;
+}
+function componentToContext(name) {
+  return COMPONENT_TO_CONTEXT[name] ?? name.toLowerCase();
+}
+function mapViewPreset(value) {
+  if (value === void 0 || value === null) return "2";
+  const v = String(value).toLowerCase().replace(/[\s_-]+/g, "");
+  return VIEW_PRESET_MAP[v] ?? String(value);
+}
+function mapRowHeight(value) {
+  if (value === void 0 || value === null) return 38;
+  const v = String(value).toLowerCase().replace(/[\s_-]+/g, "");
+  if (ROW_HEIGHT_MAP[v] !== void 0) return ROW_HEIGHT_MAP[v];
+  const parsed = parseInt(String(value), 10);
+  return isNaN(parsed) ? 38 : parsed;
+}
+function workspaceNodeToGL(node) {
+  const gl = { type: node.type };
+  if ("width" in node && node.width !== void 0) {
+    gl.width = node.width;
+  }
+  if ("height" in node && node.height !== void 0) {
+    gl.height = node.height;
+  }
+  if (node.type === "row" || node.type === "column" || node.type === "stack") {
+    gl.isClosable = true;
+    gl.reorderEnabled = true;
+    gl.title = "";
+    if ("content" in node && node.content) {
+      gl.content = node.content.map(workspaceNodeToGL);
+    }
+    if (node.type === "stack") {
+      gl.activeItemIndex = 0;
+    }
+    return gl;
+  }
+  if (node.type === "component") {
+    const compName = componentToGlName(node.component);
+    if (compName) {
+      gl.componentName = compName;
+    }
+    if (node.title !== void 0) {
+      gl.title = node.title;
+    }
+    gl.isClosable = true;
+    gl.reorderEnabled = true;
+    const compState = {};
+    const compId = node.id;
+    if (compId) {
+      gl.id = compId;
+      compState.id = compId;
+    } else if (compName === "schedulerComponent") {
+      gl.id = "schedulerContainer";
+      compState.id = "scheduler";
+    }
+    if (compName === "datePickerComponent" && compId) {
+      compState.wrapperId = compId;
+    }
+    if (Object.keys(compState).length > 0) {
+      gl.componentState = compState;
+    }
+    return gl;
+  }
+  return gl;
+}
+function workspaceToGoldenLayout(workspace) {
+  return {
+    settings: {
+      hasHeaders: true,
+      constrainDragToContainer: false,
+      reorderEnabled: true,
+      selectionEnabled: true,
+      popoutWholeStack: false,
+      blockedPopoutsThrowError: true,
+      closePopoutsOnUnload: true,
+      showPopoutIcon: false,
+      showMaximiseIcon: true,
+      showCloseIcon: true,
+      responsiveMode: "onload",
+      tabOverlapAllowance: 0,
+      reorderOnTabMenuClick: true,
+      tabControlOffset: 10
+    },
+    dimensions: {
+      borderWidth: 5,
+      borderGrabWidth: 15,
+      minItemHeight: 10,
+      minItemWidth: 10,
+      headerHeight: 20,
+      dragProxyWidth: 300,
+      dragProxyHeight: 200
+    },
+    labels: {
+      close: "Close",
+      maximise: "Maximize",
+      minimise: "Minimize",
+      popout: "open in new window",
+      popin: "pop in",
+      tabDropdown: "Additional Tabs"
+    },
+    content: [
+      {
+        type: "row",
+        isClosable: true,
+        reorderEnabled: true,
+        title: "",
+        content: workspace.map(workspaceNodeToGL)
+      }
+    ],
+    isClosable: true,
+    reorderEnabled: true,
+    title: "",
+    openPopouts: [],
+    maximisedItemId: null
+  };
+}
+function buildLayoutState(layout, gridName) {
+  const columns = (layout.columns || []).filter((c) => c.property).map((c) => ({ dataIndex: c.property }));
+  const sorters = (layout.sorters || []).filter((s) => s.property && s.direction).map((s) => ({ direction: s.direction, property: s.property }));
+  let grouper = null;
+  if (layout.grouper && layout.grouper.property && layout.grouper.direction) {
+    grouper = {
+      root: "data",
+      property: layout.grouper.property,
+      direction: layout.grouper.direction,
+      id: layout.grouper.id || layout.grouper.property
+    };
+  }
+  const filters = (layout.filters || []).map((f) => ({
+    operator: f.operator || "like",
+    value: f.value || "",
+    property: f.property,
+    exactMatch: f.exactMatch ?? false
+  }));
+  const lockedGridWidth = layout.lockedGridWidth || layout.resourcesGridWidth || null;
+  const fitToScreen = typeof layout.fitToScreen === "boolean" ? layout.fitToScreen : layout.fitToScreen === "true";
+  const ignoreCalendars = typeof layout.ignoreCalendars === "boolean" ? layout.ignoreCalendars : layout.ignoreCalendars === "true";
+  const pageSize = layout.pageSize !== void 0 ? typeof layout.pageSize === "number" ? layout.pageSize : parseInt(String(layout.pageSize), 10) : 50;
+  const state = {
+    columns,
+    storeState: grouper ? { grouper } : {},
+    filters,
+    viewPreset: layout.viewPreset !== void 0 ? mapViewPreset(layout.viewPreset) : null,
+    Id: layout.id || gridName,
+    lockedGridWidth,
+    pageSize: isNaN(pageSize) ? 50 : pageSize,
+    fitToScreen,
+    rowHeight: mapRowHeight(layout.rowHeight),
+    ignoreCalendars
+  };
+  if (sorters.length > 0) {
+    state.sorters = sorters;
+  }
+  if (layout.default) {
+    state.default = true;
+  }
+  if (layout.name) {
+    state.name = layout.name;
+  }
+  const extraFields = [
+    "viewLayoutType",
+    "startRowGroupsCollapsed",
+    "startColGroupsCollapsed",
+    "enableColumnSort",
+    "expandedItems",
+    "matrix",
+    "pivotcolumns",
+    "collapsed",
+    "hideEmptyRows"
+  ];
+  for (const field of extraFields) {
+    if (layout[field] !== void 0) {
+      state[field] = layout[field];
+    }
+  }
+  return state;
+}
+function collectLayouts(nodes) {
+  const acc = [];
+  for (const node of nodes) {
+    if (node.type === "row" || node.type === "column" || node.type === "stack") {
+      if ("content" in node && node.content) {
+        acc.push(...collectLayouts(node.content));
+      }
+    } else if (node.type === "component") {
+      const layouts = node.layouts || [];
+      const layoutArray = Array.isArray(layouts) ? layouts : [layouts];
+      for (const layoutItem of layoutArray) {
+        const context = componentToContext(node.component);
+        let gridName;
+        if (node.component === "planningBoard" && !layoutItem.id) {
+          gridName = "scheduler_panel";
+        } else {
+          gridName = layoutItem.id || `${node.id}_panel`;
+        }
+        const layoutName = layoutItem.name || node.title || gridName;
+        let layoutCode = layoutItem.code;
+        if (!layoutCode && gridName) {
+          layoutCode = gridName.toUpperCase().replace(/-/g, "_");
+        }
+        acc.push({
+          context,
+          grid: gridName,
+          value: buildLayoutState(layoutItem, gridName),
+          name: layoutName,
+          code: layoutCode || gridName.toUpperCase(),
+          componentId: gridName,
+          default: layoutItem.default ?? false,
+          public: layoutItem.shared?.public ?? false,
+          userGroup: layoutItem.shared?.userGroup
+        });
+      }
+    }
+  }
+  return acc;
+}
+function buildLayoutDtos(workspace) {
+  const layouts = collectLayouts(workspace);
+  return layouts.map((L) => ({
+    context: L.context,
+    grid: L.grid,
+    value: JSON.stringify(L.value),
+    default: L.default,
+    public: L.public,
+    userGroup: L.userGroup,
+    isOwner: true,
+    isNew: true,
+    name: L.name,
+    code: L.code
+  }));
+}
+function buildProfileLayoutDtos(workspace, profileCode) {
+  const layouts = collectLayouts(workspace);
+  return layouts.filter((L) => L.default && L.code).map((L) => ({
+    profileCode,
+    layoutCode: L.code,
+    default: true,
+    public: false,
+    name: L.componentId
+  }));
+}
+function compileProfile(profile) {
+  const theme = profile.theme || { color: "default", scheme: "sdtd" };
+  const shared = profile.shared || { global: false, userGroup: "" };
+  const route = profile.route || {
+    profile: "default",
+    calculateRoutes: true,
+    showSequenceIndicators: true,
+    unitOfDistance: "km"
+  };
+  const planning = profile.planning || {
+    snapInterval: { mode: "1hour", value: 0 },
+    range: { mode: "week", value: 0 },
+    start: { mode: "startOfWeek", value: 2 },
+    hours: { start: 8, end: 18 }
+  };
+  const workspace = profile.workspace || [];
+  const goldenLayout = workspaceToGoldenLayout(workspace);
+  const layouts = buildLayoutDtos(workspace);
+  const profileLayouts = buildProfileLayoutDtos(workspace, profile.code || "");
+  return {
+    profile: {
+      name: profile.name || "",
+      code: profile.code || "",
+      color: theme.color || "default",
+      theme: theme.scheme || "sdtd",
+      public: shared.global ?? false,
+      userGroup: shared.userGroup || "",
+      snapMode: mapSnapMode(planning.snapInterval?.mode),
+      snapValue: planning.snapInterval?.value ?? null,
+      rangeMode: mapRangeMode(planning.range?.mode),
+      rangeValue: planning.range?.value ?? null,
+      startMode: mapStartMode(planning.start?.mode),
+      startValue: planning.start?.value ?? null,
+      startTime: planning.hours?.start ?? 8,
+      endTime: planning.hours?.end ?? 18,
+      unitOfDistance: mapUnitOfDistance(route.unitOfDistance),
+      autoRouteCalculation: route.calculateRoutes ?? true,
+      showSequenceIndicators: route.showSequenceIndicators ?? true,
+      routeProfile: route.profile || "default",
+      layout: JSON.stringify(goldenLayout)
+    },
+    layouts,
+    profileLayouts,
+    users: profile.users || [],
+    owner: profile.owner,
+    notificationEmail: profile.notificationEmail
+  };
+}
+
+// src/commands/validate.ts
+var validateCommand = new Command("validate").description("Validate a configuration file").argument("<file>", "Path to the configuration file (.json5 or .json)").option("--json", "Output results as JSON").action((file, options) => {
+  try {
+    const filePath = resolve(normalize(file));
+    const content = readFileSync(filePath, "utf-8");
+    let profile;
+    try {
+      profile = JSON5.parse(content);
+    } catch {
+      if (options.json) {
+        console.log(JSON.stringify({ valid: false, errors: [{ type: "error", message: "Invalid JSON5 syntax" }], warnings: [] }));
+      } else {
+        console.error(pc.red("Error:"), "Invalid JSON5 syntax in", file);
+      }
+      process.exit(1);
+    }
+    const result = validateProfile(profile);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      if (result.valid) {
+        console.log(pc.green("\u2713"), "Configuration is valid");
+      } else {
+        console.log(pc.red("\u2717"), "Configuration has errors");
+      }
+      if (result.errors.length > 0) {
+        console.log();
+        console.log(pc.red("Errors:"));
+        for (const error of result.errors) {
+          console.log(pc.red("  \u2022"), error.message);
+        }
+      }
+      if (result.warnings.length > 0) {
+        console.log();
+        console.log(pc.yellow("Warnings:"));
+        for (const warning of result.warnings) {
+          console.log(pc.yellow("  \u2022"), warning.message);
+        }
+      }
+    }
+    process.exit(result.valid ? 0 : 1);
+  } catch (err) {
+    if (options.json) {
+      console.log(JSON.stringify({ valid: false, errors: [{ type: "error", message: String(err) }], warnings: [] }));
+    } else {
+      console.error(pc.red("Error:"), String(err));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/compile.ts
+import { Command as Command2 } from "commander";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { resolve as resolve2, normalize as normalize2, dirname, basename, extname } from "path";
+import JSON52 from "json5";
+import pc2 from "picocolors";
+var compileCommand = new Command2("compile").description("Compile a JSON5 configuration to API-ready JSON").argument("<file>", "Path to the configuration file (.json5)").option("-o, --output <dir>", "Output directory (default: same as input)").option("--stdout", "Output to stdout instead of file").option("--skip-validation", "Skip validation before compiling").action((file, options) => {
+  try {
+    const filePath = resolve2(normalize2(file));
+    const content = readFileSync2(filePath, "utf-8");
+    let profile;
+    try {
+      profile = JSON52.parse(content);
+    } catch {
+      console.error(pc2.red("Error:"), "Invalid JSON5 syntax in", file);
+      process.exit(1);
+    }
+    if (!options.skipValidation) {
+      const validation = validateProfile(profile);
+      if (!validation.valid) {
+        console.error(pc2.red("Error:"), "Configuration has validation errors:");
+        for (const error of validation.errors) {
+          console.error(pc2.red("  \u2022"), error.message);
+        }
+        console.error();
+        console.error("Use --skip-validation to compile anyway");
+        process.exit(1);
+      }
+    }
+    const payload = compileProfile(profile);
+    const jsonOutput = JSON.stringify(payload, null, 2);
+    if (options.stdout) {
+      console.log(jsonOutput);
+    } else {
+      const inputBasename = basename(file, extname(file));
+      const outputDir = options.output ? resolve2(normalize2(options.output)) : dirname(filePath);
+      const outputPath = resolve2(outputDir, `${inputBasename}.json`);
+      mkdirSync(outputDir, { recursive: true });
+      writeFileSync(outputPath, jsonOutput, "utf-8");
+      console.log(pc2.green("\u2713"), "Compiled to", outputPath);
+    }
+    process.exit(0);
+  } catch (err) {
+    console.error(pc2.red("Error:"), String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/deploy.ts
+import { Command as Command3 } from "commander";
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3, normalize as normalize3 } from "path";
+import { createInterface } from "readline";
+import JSON53 from "json5";
+import pc3 from "picocolors";
+var ENVIRONMENT_URLS = {
+  production: "https://api.dimescheduler.com",
+  sandbox: "https://sandbox.api.dimescheduler.com",
+  test: "https://test.api.dimescheduler.com"
+};
+async function confirm(message) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve4) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve4(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function deployToApi(payload, url, apiKey) {
+  try {
+    const response = await fetch(`${url}/import/setup`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-KEY": apiKey
+      },
+      body: JSON.stringify(payload)
+    });
+    if (response.ok) {
+      return { success: true, message: "Profile deployed successfully" };
+    } else {
+      const text = await response.text();
+      return { success: false, message: `HTTP ${response.status}`, error: text };
+    }
+  } catch (err) {
+    return { success: false, message: "Request failed", error: String(err) };
+  }
+}
+var deployCommand = new Command3("deploy").description("Deploy a configuration to a Dime Scheduler instance").argument("<file>", "Path to the configuration file (.json5 or .json)").requiredOption("--api-key <key>", "API key for authentication (or set DS_API_KEY env var)").requiredOption("--env <environment>", "Environment: production, sandbox, or test").option("--skip-validation", "Skip validation before deploying").option("--json", "Output results as JSON").option("--dry-run", "Validate and compile but do not deploy").option("-y, --yes", "Skip confirmation prompt").action(async (file, options) => {
+  try {
+    const filePath = resolve3(normalize3(file));
+    const content = readFileSync3(filePath, "utf-8");
+    const apiKey = options.apiKey || process.env.DS_API_KEY;
+    if (!apiKey) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: "API key is required. Use --api-key or set DS_API_KEY environment variable." }));
+      } else {
+        console.error(pc3.red("Error:"), "API key is required. Use --api-key or set DS_API_KEY environment variable.");
+      }
+      process.exit(1);
+    }
+    if (!ENVIRONMENT_URLS[options.env]) {
+      const validEnvs = Object.keys(ENVIRONMENT_URLS).join(", ");
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: `Invalid environment: ${options.env}. Valid options: ${validEnvs}` }));
+      } else {
+        console.error(pc3.red("Error:"), `Invalid environment: ${options.env}. Valid options: ${validEnvs}`);
+      }
+      process.exit(1);
+    }
+    const apiUrl = ENVIRONMENT_URLS[options.env];
+    let profile;
+    try {
+      profile = JSON53.parse(content);
+    } catch {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: "Invalid JSON5 syntax" }));
+      } else {
+        console.error(pc3.red("Error:"), "Invalid JSON5 syntax in", file);
+      }
+      process.exit(1);
+    }
+    if (!options.skipValidation) {
+      const validation = validateProfile(profile);
+      if (!validation.valid) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: "Validation failed", details: validation.errors }));
+        } else {
+          console.error(pc3.red("Error:"), "Configuration has validation errors:");
+          for (const error of validation.errors) {
+            console.error(pc3.red("  \u2022"), error.message);
+          }
+        }
+        process.exit(1);
+      }
+    }
+    const payload = compileProfile(profile);
+    if (options.dryRun) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, message: "Dry run successful", payload }));
+      } else {
+        console.log(pc3.green("\u2713"), "Dry run successful - configuration is valid and compiled");
+        console.log(pc3.dim("  Would deploy to:"), apiUrl);
+      }
+      process.exit(0);
+    }
+    if (!options.yes && !options.json) {
+      console.log();
+      console.log(pc3.bold("Deploy Summary:"));
+      console.log(`  Profile: ${pc3.cyan(profile.name || "unnamed")} (${profile.code || "no code"})`);
+      console.log(`  Environment: ${pc3.yellow(options.env)}`);
+      console.log(`  Target: ${pc3.dim(apiUrl)}`);
+      console.log();
+      const confirmed = await confirm("Proceed with deployment?");
+      if (!confirmed) {
+        console.log(pc3.dim("Deployment cancelled."));
+        process.exit(0);
+      }
+    }
+    if (!options.json) {
+      console.log(pc3.dim("Deploying..."));
+    }
+    const result = await deployToApi(payload, apiUrl, apiKey);
+    if (options.json) {
+      console.log(JSON.stringify(result));
+    } else {
+      if (result.success) {
+        console.log(pc3.green("\u2713"), result.message);
+      } else {
+        console.error(pc3.red("\u2717"), result.message);
+        if (result.error) {
+          console.error(pc3.dim("  "), result.error);
+        }
+      }
+    }
+    process.exit(result.success ? 0 : 2);
+  } catch (err) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: String(err) }));
+    } else {
+      console.error(pc3.red("Error:"), String(err));
+    }
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command4();
+program.name("dimescheduler-setup").description("CLI tool to validate, compile, and deploy Dime Scheduler configurations").version("0.1.0");
+program.addCommand(validateCommand);
+program.addCommand(compileCommand);
+program.addCommand(deployCommand);
+program.parse();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@dimescheduler/setup",
+  "version": "0.1.0",
+  "description": "CLI tool to validate, compile, and deploy Dime Scheduler configurations",
+  "type": "module",
+  "bin": {
+    "dimescheduler-setup": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "watch": "tsup src/index.ts --format esm --watch",
+    "start": "node dist/index.js",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "json5": "^2.2.3",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dimescheduler/dsl.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "dimescheduler",
+    "cli",
+    "configuration",
+    "scheduling"
+  ],
+  "author": "Dime Software",
+  "license": "MIT"
+}