@codemieai/cdk 0.1.270

package/dist/index.js

@@ -0,0 +1,3247 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import * as crypto from 'crypto';
+import { CodeMieClient, DataSourceType } from 'codemie-sdk';
+import 'dotenv/config';
+import pLimit from 'p-limit';
+
+// src/lib/codemieConfigLoader.ts
+var CodemieConfigLoader = class {
+  appConfig;
+  constructor(appConfig) {
+    this.appConfig = appConfig;
+  }
+  /**
+   * Load and parse the main codemie.yaml configuration file
+   */
+  loadConfig() {
+    const { rootDir, codemieConfig } = this.appConfig;
+    const configPath = path.join(rootDir, codemieConfig);
+    if (!fs.existsSync(configPath)) {
+      throw new Error(`Configuration file not found: ${configPath}`);
+    }
+    const content = fs.readFileSync(configPath, "utf8");
+    const config = yaml.parse(content);
+    this.resolveImports(config, rootDir);
+    this.substituteEnvVars(config);
+    this.applyDatasourceDefaults(config);
+    this.resolveReferencesRecursive(config, config);
+    this.validateDatasourceIntegrationReferences(config);
+    return config;
+  }
+  /**
+   * Load assistant prompt file
+   */
+  loadPrompt(promptPath) {
+    const { rootDir } = this.appConfig;
+    const fullPath = path.join(rootDir, promptPath);
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Prompt file not found: ${fullPath}`);
+    }
+    return fs.readFileSync(fullPath, "utf8");
+  }
+  /**
+   * Load assistant configuration file
+   */
+  loadAssistantConfig(configPath) {
+    const { rootDir } = this.appConfig;
+    const fullPath = path.join(rootDir, configPath);
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Config file not found: ${fullPath}`);
+    }
+    const content = fs.readFileSync(fullPath, "utf8");
+    return yaml.parse(content);
+  }
+  /**
+   * Validate that all referenced files exist
+   */
+  validateFiles(config) {
+    const errors = [];
+    const { rootDir } = this.appConfig;
+    if (config.resources.assistants) {
+      for (const assistant of config.resources.assistants) {
+        const promptPath = path.join(rootDir, assistant.prompt);
+        if (!fs.existsSync(promptPath)) {
+          errors.push(`Prompt file not found for ${assistant.name}: ${assistant.prompt}`);
+        }
+        if (assistant.config) {
+          const configPath = path.join(rootDir, assistant.config);
+          if (!fs.existsSync(configPath)) {
+            errors.push(`Config file not found for ${assistant.name}: ${assistant.config}`);
+          }
+        }
+        if (!assistant.description) {
+          errors.push(`Missing 'description' for assistant: ${assistant.name}`);
+        }
+        if (!assistant.model) {
+          errors.push(`Missing 'model' for assistant: ${assistant.name}`);
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Resolve $import directives recursively
+   * Automatically handles:
+   * 1. Single resource import (object)
+   * 2. Multiple resources import (array)
+   * 3. Mixed inline + imports
+   * Includes circular import detection to prevent infinite recursion
+   */
+  resolveImports(obj, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
+    if (!this.isPlainObject(obj)) {
+      return;
+    }
+    for (const key in obj) {
+      const value = obj[key];
+      if (this.isPlainObject(value) && "$import" in value) {
+        const importDirective = value;
+        const importPath = path.join(baseDir, importDirective.$import);
+        const normalizedPath = path.resolve(importPath);
+        if (visitedFiles.has(normalizedPath)) {
+          throw new Error(
+            `Circular import detected: ${normalizedPath}
+Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
+          );
+        }
+        visitedFiles.add(normalizedPath);
+        const imported = this.loadYamlFile(importPath);
+        obj[key] = imported;
+        this.resolveImports(obj[key], path.dirname(importPath), visitedFiles);
+        visitedFiles.delete(normalizedPath);
+      } else if (Array.isArray(value)) {
+        obj[key] = this.resolveArrayImports(value, baseDir, visitedFiles);
+      } else if (this.isPlainObject(value)) {
+        this.resolveImports(value, baseDir, visitedFiles);
+      }
+    }
+  }
+  /**
+   * Resolve imports in arrays
+   * Intelligently handles:
+   * - Inline objects (keep as-is)
+   * - $import with single object (add to array)
+   * - $import with array (flatten into parent array)
+   * Includes circular import detection
+   */
+  resolveArrayImports(arr, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
+    const result = [];
+    for (const item of arr) {
+      if (this.isPlainObject(item) && "$import" in item) {
+        const importDirective = item;
+        const importPath = path.join(baseDir, importDirective.$import);
+        const normalizedPath = path.resolve(importPath);
+        if (visitedFiles.has(normalizedPath)) {
+          throw new Error(
+            `Circular import detected: ${normalizedPath}
+Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
+          );
+        }
+        visitedFiles.add(normalizedPath);
+        const imported = this.loadYamlFile(importPath);
+        if (Array.isArray(imported)) {
+          const resolvedArray = this.resolveArrayImports(imported, path.dirname(importPath), visitedFiles);
+          for (const resolvedItem of resolvedArray) {
+            result.push(resolvedItem);
+          }
+        } else if (this.isPlainObject(imported)) {
+          result.push(imported);
+          this.resolveImports(imported, path.dirname(importPath), visitedFiles);
+        } else {
+          throw new TypeError(
+            `Import file ${importPath} must contain either an object or an array. Got: ${typeof imported}`
+          );
+        }
+        visitedFiles.delete(normalizedPath);
+      } else {
+        result.push(item);
+        if (this.isPlainObject(item)) {
+          this.resolveImports(item, baseDir, visitedFiles);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Load YAML file with error handling
+   */
+  loadYamlFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Import file not found: ${filePath}`);
+    }
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      const parsed = yaml.parse(content);
+      if (parsed === null || parsed === void 0) {
+        throw new TypeError(`Import file ${filePath} is empty`);
+      }
+      return parsed;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new TypeError(`Failed to parse YAML file ${filePath}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Recursively resolve all $ref in an object/array structure
+   * Handles both object references { $ref: "path" } and string references "$ref:path"
+   *
+   * @param current - Current node being processed (starts with root config, then recurses into children)
+   * @param rootConfig - Root config object (constant reference for resolving paths like "imported.integrations.xxx")
+   * @param path - Current path in config tree (for error messages, e.g., "resources.assistants[0].toolkits")
+   */
+  resolveReferencesRecursive(current, rootConfig, path11 = "") {
+    if (!current || typeof current !== "object") {
+      return;
+    }
+    if (Array.isArray(current)) {
+      this.resolveArrayReferences(current, rootConfig, path11);
+      return;
+    }
+    if ("$ref" in current && typeof current.$ref === "string") {
+      this.resolveObjectReference(current, rootConfig, path11);
+      return;
+    }
+    this.resolveObjectProperties(current, rootConfig, path11);
+  }
+  /**
+   * Resolve $ref items in arrays and flatten if they point to arrays
+   * Example: [{ $ref: "context_definitions.repos" }] where repos is [item1, item2]
+   * becomes [item1, item2]
+   */
+  resolveArrayReferences(arr, rootConfig, path11) {
+    const result = arr.flatMap((item, i) => {
+      const contextPath = `${path11}[${i}]`;
+      if (!this.isRefObject(item) || item.$ref.startsWith("#")) {
+        this.resolveReferencesRecursive(item, rootConfig, contextPath);
+        return [item];
+      }
+      const resolved = this.resolveReference(rootConfig, item.$ref, contextPath);
+      if (Array.isArray(resolved)) {
+        return structuredClone(resolved);
+      }
+      this.resolveObjectReference(item, rootConfig, contextPath);
+      return [item];
+    });
+    arr.splice(0, arr.length, ...result);
+  }
+  /**
+   * Resolve object reference: { $ref: "path" }
+   * Replaces object with resolved data (in-place mutation)
+   */
+  resolveObjectReference(current, rootConfig, path11) {
+    const refPath = current.$ref;
+    const contextPath = path11 || "root";
+    if (refPath.startsWith("#")) {
+      return;
+    }
+    const resolved = this.resolveReference(rootConfig, refPath, contextPath);
+    const filteredResolved = Object.fromEntries(Object.entries(resolved).filter(([, value]) => value !== void 0));
+    for (const key of Object.keys(current)) {
+      delete current[key];
+    }
+    Object.assign(current, filteredResolved);
+    this.resolveReferencesRecursive(current, rootConfig, path11);
+  }
+  /**
+   * Resolve object properties recursively
+   * Handles both nested objects and "$ref:path" string references
+   */
+  resolveObjectProperties(current, rootConfig, path11) {
+    for (const [key, value] of Object.entries(current)) {
+      if (typeof value === "string" && value.startsWith("$ref:")) {
+        const refPath = value.slice(5);
+        if (refPath.startsWith("#")) {
+          continue;
+        }
+        const contextPath = path11 ? `${path11}.${key}` : key;
+        const resolved = this.resolveReference(rootConfig, refPath, contextPath);
+        current[key] = resolved;
+      } else {
+        this.resolveReferencesRecursive(value, rootConfig, path11 ? `${path11}.${key}` : key);
+      }
+    }
+  }
+  /**
+   * Validate that datasource setting_id fields are strings (not objects)
+   * For datasources, setting_id must reference a string UUID, not an integration object
+   * Users should use .id suffix: $ref:imported.integrations.git_conn.id
+   */
+  validateDatasourceIntegrationReferences(config) {
+    if (!config.resources.datasources) {
+      return;
+    }
+    for (const datasource of config.resources.datasources) {
+      if (datasource.setting_id && typeof datasource.setting_id !== "string") {
+        throw new TypeError(
+          `Datasource "${datasource.name}" setting_id must point to a string UUID value, but resolved to an object. Add ".id" suffix to reference the integration ID. Example: setting_id: $ref:imported.integrations.git_conn.id`
+        );
+      }
+    }
+  }
+  /**
+   * Resolve a reference path like "imported.integrations.jira_main" or "tool_definitions.jira_tool"
+   * Supports nested paths like "imported.integrations.jira_main.id" to access specific fields
+   * Returns the referenced object or value from config
+   *
+   * Special handling for arrays:
+   * - imported.integrations (array): searches by 'alias' field
+   * - imported.assistants (array): searches by 'name' field
+   * - imported.datasources (array): searches by 'name' field
+   */
+  resolveReference(config, ref, context) {
+    const parts = ref.split(".");
+    if (parts.length < 2) {
+      throw new Error(
+        `Invalid $ref format: "${ref}". Expected format: "imported.integrations.name" or "tool_definitions.name". You can also use nested paths like "imported.integrations.name.id". Referenced in ${context}.`
+      );
+    }
+    let current = config;
+    const pathParts = [];
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      pathParts.push(part);
+      if (!current || typeof current !== "object" || !(part in current)) {
+        throw new Error(
+          `Reference path "${ref}" not found: "${pathParts.join(".")}" does not exist. Referenced in ${context}.`
+        );
+      }
+      current = current[part];
+      const hasMorePathSegments = i + 1 < parts.length;
+      if (Array.isArray(current) && hasMorePathSegments) {
+        const nextPathSegment = parts[i + 1];
+        const searchField = part === "integrations" ? "alias" : "name";
+        const foundItem = current.find(
+          (item) => typeof item === "object" && item !== null && item[searchField] === nextPathSegment
+        );
+        if (!foundItem) {
+          throw new Error(
+            `Reference path "${ref}" not found: no item with ${searchField}="${nextPathSegment}" in "${pathParts.join(".")}". Referenced in ${context}.`
+          );
+        }
+        current = foundItem;
+        pathParts.push(nextPathSegment);
+        i++;
+      }
+    }
+    return current;
+  }
+  /**
+   * Apply datasource defaults based on $ref or type
+   * Priority: $ref (explicit) > type (fallback)
+   */
+  applyDatasourceDefaults(config) {
+    if (!config.datasource_defaults || !config.resources.datasources) {
+      return;
+    }
+    config.resources.datasources = config.resources.datasources.map((datasource) => {
+      let defaults = null;
+      if (datasource.$ref) {
+        const refPath = datasource.$ref.startsWith("$ref:") ? datasource.$ref.slice(5) : datasource.$ref;
+        defaults = this.resolveReference(config, refPath, `datasource "${datasource.name}".$ref`);
+        if (!defaults || typeof defaults !== "object") {
+          throw new Error(
+            `Invalid $ref in datasource "${datasource.name}": "${refPath}" does not point to a valid datasource defaults object`
+          );
+        }
+      } else if (datasource.type) {
+        defaults = config.datasource_defaults[datasource.type];
+      }
+      if (!defaults) {
+        return datasource;
+      }
+      const { $ref: _ref, ...datasourceWithoutRef } = datasource;
+      return {
+        ...defaults,
+        ...datasourceWithoutRef
+      };
+    });
+  }
+  /**
+   * Type guard to check if value is a plain object (not array, not null)
+   */
+  isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  isRefObject(item) {
+    return this.isPlainObject(item) && "$ref" in item && typeof item.$ref === "string";
+  }
+  /**
+   * Substitute environment variables in configuration
+   * Supports syntax:
+   * - ${VAR_NAME} - required variable (throws if not set)
+   * - ${VAR_NAME:-default} - optional with default value (shell-style)
+   * - ${VAR_NAME:default} - optional with default value (simplified)
+   * - ${VAR_NAME:-} or ${VAR_NAME:} - optional with empty string default
+   */
+  substituteEnvVars(obj) {
+    for (const key in obj) {
+      if (typeof obj[key] === "string") {
+        obj[key] = obj[key].replaceAll(
+          /\$\{([^:}]+)(?::-?([^}]*))?\}/g,
+          (match, varName, defaultValue) => {
+            const value = process.env[varName];
+            if (value === void 0) {
+              if (defaultValue !== void 0) {
+                return defaultValue;
+              }
+              throw new Error(`Environment variable ${varName} is not set`);
+            }
+            return value;
+          }
+        );
+      } else if (this.isPlainObject(obj[key])) {
+        this.substituteEnvVars(obj[key]);
+      }
+    }
+  }
+};
+
+// src/lib/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class _Logger {
+  static instance;
+  level = 1 /* INFO */;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger();
+    }
+    return _Logger.instance;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.debug(message, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(message, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(message, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(message, ...args);
+    }
+  }
+};
+var logger = Logger.getInstance();
+
+// src/lib/checksumUtils.ts
+var DEFAULT_LLM_MODEL = "gpt-4";
+function normalizeIntegrationSettings(settings) {
+  if (!settings || typeof settings !== "object") {
+    return settings;
+  }
+  if ("$ref" in settings && typeof settings.$ref === "string") {
+    return { $ref: settings.$ref };
+  }
+  if ("alias" in settings && typeof settings.alias === "string") {
+    return { $ref: `imported.integrations.${settings.alias}` };
+  }
+  return settings;
+}
+function normalizeTool(tool) {
+  return {
+    name: tool.name,
+    label: tool.label,
+    settings_config: tool.settings_config,
+    user_description: tool.user_description,
+    settings: normalizeIntegrationSettings(tool.settings)
+  };
+}
+function normalizeToolkits(toolkits) {
+  if (!toolkits) {
+    return [];
+  }
+  return toolkits.map(({ toolkit, tools, label, settings_config, is_external, settings }) => ({
+    toolkit,
+    label,
+    settings_config,
+    is_external,
+    tools: tools?.map((tool) => normalizeTool(tool)),
+    settings: normalizeIntegrationSettings(settings)
+  }));
+}
+function normalizeMcpServers(mcpServers) {
+  if (!mcpServers) {
+    return [];
+  }
+  return mcpServers.map((mcp) => ({
+    ...mcp,
+    settings: normalizeIntegrationSettings(mcp.settings),
+    mcp_connect_auth_token: normalizeIntegrationSettings(mcp.mcp_connect_auth_token)
+  }));
+}
+function calculateChecksum(content) {
+  if (typeof content !== "string") {
+    throw new TypeError(`calculateChecksum expects string, got ${typeof content}`);
+  }
+  if (content.length === 0) {
+    logger.warn("\u26A0\uFE0F  Calculating checksum of empty string");
+  }
+  return crypto.createHash("sha256").update(content, "utf8").digest("hex");
+}
+function normalizeAssistantConfig(assistant, buildConfig = null) {
+  return {
+    description: assistant.description || "",
+    model: assistant.model || DEFAULT_LLM_MODEL,
+    temperature: assistant.temperature,
+    top_p: assistant.top_p,
+    shared: assistant.shared,
+    is_react: assistant.is_react,
+    is_global: assistant.is_global,
+    icon_url: assistant.icon_url,
+    toolkits: normalizeToolkits(assistant.toolkits),
+    context: assistant.context || [],
+    mcp_servers: normalizeMcpServers(assistant.mcp_servers),
+    assistant_ids: assistant.assistant_ids || [],
+    sub_assistants: assistant.sub_assistants || [],
+    conversation_starters: assistant.conversation_starters || [],
+    buildConfig
+  };
+}
+function calculateAssistantConfigChecksum(assistant, buildConfig = null) {
+  const normalized = normalizeAssistantConfig(assistant, buildConfig);
+  return calculateChecksum(JSON.stringify(normalized));
+}
+
+// src/lib/codemieConfigChecksums.ts
+function createExcludeSet(keys) {
+  return new Set(keys);
+}
+var DATASOURCE_EXCLUDED_FIELDS = createExcludeSet(["force_reindex"]);
+var WORKFLOW_EXCLUDED_FIELDS = createExcludeSet(["definition"]);
+function buildChecksumObject(src, excluded) {
+  const out = {};
+  const keys = Object.keys(src).sort();
+  for (const key of keys) {
+    if (excluded.has(key)) {
+      continue;
+    }
+    const value = src[key];
+    if (value !== void 0) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function calculateDatasourceConfigChecksum(datasource) {
+  const filtered = buildChecksumObject(datasource, DATASOURCE_EXCLUDED_FIELDS);
+  return calculateChecksum(JSON.stringify(filtered));
+}
+function calculateWorkflowConfigChecksum(workflow) {
+  const filtered = buildChecksumObject(workflow, WORKFLOW_EXCLUDED_FIELDS);
+  return calculateChecksum(JSON.stringify(filtered));
+}
+
+// src/lib/stateManager.ts
+var StateManager = class {
+  statePath;
+  constructor(appConfig) {
+    const { rootDir, codemieState } = appConfig;
+    this.statePath = path.join(rootDir, codemieState);
+  }
+  /**
+   * Load state file
+   */
+  loadState() {
+    if (!fs.existsSync(this.statePath)) {
+      return this.createEmptyState();
+    }
+    const content = fs.readFileSync(this.statePath, "utf8");
+    const state = JSON.parse(content);
+    if (!state.resources) {
+      state.resources = {
+        assistants: {},
+        datasources: {},
+        workflows: {}
+      };
+    }
+    if (!state.resources.assistants) {
+      state.resources.assistants = {};
+    }
+    if (!state.resources.datasources) {
+      state.resources.datasources = {};
+    }
+    if (!state.resources.workflows) {
+      state.resources.workflows = {};
+    }
+    return state;
+  }
+  /**
+   * Save state file
+   */
+  saveState(state) {
+    const dir = path.dirname(this.statePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    state.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+    fs.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
+  }
+  /**
+   * Create empty state structure
+   */
+  createEmptyState() {
+    return {
+      version: "1.0",
+      project: "",
+      lastSync: null,
+      resources: {
+        assistants: {},
+        datasources: {},
+        workflows: {}
+      }
+    };
+  }
+  /**
+   * Update assistant state (keyed by NAME)
+   * @param name
+   * @param id
+   * @param promptContent
+   * @param assistantResource - The assistant resource object (used to calculate consistent checksum)
+   * @param buildConfig - Optional build-time configuration
+   */
+  updateAssistantState(name, id, promptContent, assistantResource, buildConfig = null) {
+    const state = this.loadState();
+    state.resources.assistants[name] = {
+      id,
+      lastDeployed: (/* @__PURE__ */ new Date()).toISOString(),
+      promptChecksum: calculateChecksum(promptContent),
+      configChecksum: calculateAssistantConfigChecksum(assistantResource, buildConfig)
+    };
+    this.saveState(state);
+  }
+  /**
+   * Get assistant state by NAME
+   */
+  getAssistantState(name) {
+    const state = this.loadState();
+    return state.resources.assistants[name];
+  }
+  /**
+   * Delete assistant state by NAME
+   */
+  deleteAssistantState(name) {
+    const state = this.loadState();
+    delete state.resources.assistants[name];
+    this.saveState(state);
+  }
+  /**
+   * Update datasource state (keyed by NAME)
+   * @param datasourceResource - The datasource resource object (used to calculate consistent checksum)
+   */
+  updateDatasourceState(name, id, datasourceResource) {
+    const state = this.loadState();
+    state.resources.datasources[name] = {
+      id,
+      lastDeployed: (/* @__PURE__ */ new Date()).toISOString(),
+      configChecksum: calculateDatasourceConfigChecksum(datasourceResource)
+    };
+    this.saveState(state);
+  }
+  /**
+   * Get datasource state by NAME
+   */
+  getDatasourceState(name) {
+    const state = this.loadState();
+    return state.resources.datasources[name];
+  }
+  /**
+   * Delete datasource state by NAME
+   */
+  deleteDatasourceState(name) {
+    const state = this.loadState();
+    delete state.resources.datasources[name];
+    this.saveState(state);
+  }
+  /**
+   * Update workflow state (keyed by NAME)
+   */
+  updateWorkflowState(name, id, workflowYamlChecksum, configChecksum) {
+    const state = this.loadState();
+    state.resources.workflows[name] = {
+      id,
+      lastDeployed: (/* @__PURE__ */ new Date()).toISOString(),
+      workflowYamlChecksum,
+      configChecksum
+    };
+    this.saveState(state);
+  }
+  /**
+   * Get workflow state by NAME
+   */
+  getWorkflowState(name) {
+    const state = this.loadState();
+    return state.resources.workflows[name];
+  }
+  /**
+   * Delete workflow state by NAME
+   */
+  deleteWorkflowState(name) {
+    const state = this.loadState();
+    delete state.resources.workflows[name];
+    this.saveState(state);
+  }
+  /**
+   * Get all managed resources (for cleanup/destroy)
+   * Returns: { assistants: [name1, name2], datasources: [name1], workflows: [name1] }
+   */
+  getAllManagedResources() {
+    const state = this.loadState();
+    return {
+      assistants: Object.keys(state.resources.assistants),
+      datasources: Object.keys(state.resources.datasources),
+      workflows: Object.keys(state.resources.workflows)
+    };
+  }
+  /**
+   * Check if a resource is managed by IaC (exists in state.json)
+   * @param type Resource type ('assistant', 'datasource', 'workflow')
+   * @param name Resource name
+   */
+  isManagedResource(type, name) {
+    const state = this.loadState();
+    switch (type) {
+      case "assistant": {
+        return name in state.resources.assistants;
+      }
+      case "datasource": {
+        return name in state.resources.datasources;
+      }
+      case "workflow": {
+        return name in state.resources.workflows;
+      }
+      default: {
+        return false;
+      }
+    }
+  }
+  /**
+   * Get ID by name for a specific resource type
+   */
+  getIdByName(type, name) {
+    const state = this.loadState();
+    switch (type) {
+      case "assistant": {
+        return state.resources.assistants[name]?.id;
+      }
+      case "datasource": {
+        return state.resources.datasources[name]?.id;
+      }
+      case "workflow": {
+        return state.resources.workflows[name]?.id;
+      }
+      default: {
+        return void 0;
+      }
+    }
+  }
+};
+async function createClient(config) {
+  const client = new CodeMieClient({
+    auth_server_url: config.environment.auth_server_url,
+    auth_realm_name: config.environment.auth_realm_name,
+    codemie_api_domain: config.environment.codemie_api_url,
+    auth_client_id: config.environment.client_id,
+    auth_client_secret: config.environment.client_secret,
+    username: config.environment.username,
+    password: config.environment.password,
+    verify_ssl: true
+  });
+  await client.initialize();
+  return client;
+}
+
+// src/lib/cleanupManager.ts
+var CleanupManager = class {
+  constructor(client, stateManager) {
+    this.client = client;
+    this.stateManager = stateManager;
+  }
+  /**
+   * Check if an error indicates that a resource was not found on the platform
+   * Handles both proper 404 responses
+   */
+  isNotFoundError(error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("404") || errorMessage.includes("not found") || errorMessage.includes("Not Found")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Delete a resource with graceful handling for "not found" errors
+   * Returns true if deleted or not found, false if other error occurred
+   */
+  async deleteResourceSafely(resourceType, name, id, deleteFn) {
+    try {
+      await deleteFn();
+      logger.info(`  \u{1F5D1}\uFE0F  Deleted orphaned ${resourceType}: ${name} (${id.slice(0, 8)}...)`);
+      return { success: true, notFound: false };
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        logger.info(
+          `  \u26A0\uFE0F  ${resourceType.charAt(0).toUpperCase() + resourceType.slice(1)} ${name} not found on platform (already deleted) - removing from state`
+        );
+        return { success: true, notFound: true };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Find orphaned resources (in state but not in config)
+   * These are resources that were managed by IaC but removed from codemie.yaml
+   * Returns resource NAMES, not IDs
+   */
+  findOrphanedResources(config) {
+    const managedResources = this.stateManager.getAllManagedResources();
+    const configAssistantNames = new Set((config.resources.assistants || []).map(({ name }) => name));
+    const configDatasourceNames = new Set((config.resources.datasources || []).map(({ name }) => name));
+    const configWorkflowNames = new Set((config.resources.workflows || []).map(({ name }) => name));
+    return {
+      assistants: managedResources.assistants.filter((name) => !configAssistantNames.has(name)),
+      datasources: managedResources.datasources.filter((name) => !configDatasourceNames.has(name)),
+      workflows: managedResources.workflows.filter((name) => !configWorkflowNames.has(name))
+    };
+  }
+  /**
+   * Delete orphaned resources from platform
+   * SAFETY: Only deletes resources that are in state.json (managed by IaC)
+   * @param orphaned Object with resource NAMES (not IDs)
+   */
+  // eslint-disable-next-line max-lines-per-function
+  async deleteOrphanedResources(orphaned) {
+    const result = {
+      deleted: {
+        assistants: [],
+        datasources: [],
+        workflows: []
+      },
+      errors: []
+    };
+    for (const name of orphaned.assistants) {
+      try {
+        if (!this.stateManager.isManagedResource("assistant", name)) {
+          logger.info(`  \u26A0\uFE0F  Skipping ${name} - not in state (safety check)`);
+          continue;
+        }
+        const id = this.stateManager.getIdByName("assistant", name);
+        if (!id) {
+          logger.info(`  \u26A0\uFE0F  Skipping ${name} - no ID in state`);
+          continue;
+        }
+        await this.deleteResourceSafely("assistant", name, id, () => this.client.assistants.delete(id));
+        this.stateManager.deleteAssistantState(name);
+        result.deleted.assistants.push(name);
+      } catch (error) {
+        result.errors.push({
+          type: "assistant",
+          name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        logger.error(
+          `  \u274C Failed to delete assistant ${name}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    for (const name of orphaned.datasources) {
+      try {
+        if (!this.stateManager.isManagedResource("datasource", name)) {
+          logger.info(`  \u26A0\uFE0F  Skipping ${name} - not in state (safety check)`);
+          continue;
+        }
+        const id = this.stateManager.getIdByName("datasource", name);
+        if (!id) {
+          logger.info(`  \u26A0\uFE0F  Skipping ${name} - no ID in state`);
+          continue;
+        }
+        await this.deleteResourceSafely("datasource", name, id, () => this.client.datasources.delete(id));
+        this.stateManager.deleteDatasourceState(name);
+        result.deleted.datasources.push(name);
+      } catch (error) {
+        result.errors.push({
+          type: "datasource",
+          name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        logger.error(
+          `  \u274C Failed to delete datasource ${name}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    for (const name of orphaned.workflows) {
+      try {
+        if (!this.stateManager.isManagedResource("workflow", name)) {
+          logger.info(`  \u26A0\uFE0F  Skipping ${name} - not in state (safety check)`);
+          continue;
+        }
+        const id = this.stateManager.getIdByName("workflow", name);
+        if (!id) {
+          logger.info(`  \u26A0\uFE0F  Skipping ${name} - no ID in state`);
+          continue;
+        }
+        await this.deleteResourceSafely("workflow", name, id, () => this.client.workflows.delete(id));
+        this.stateManager.deleteWorkflowState(name);
+        result.deleted.workflows.push(name);
+      } catch (error) {
+        result.errors.push({
+          type: "workflow",
+          name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        logger.error(
+          `  \u274C Failed to delete workflow ${name}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return result;
+  }
+  /**
+   * Get summary of orphaned resources
+   */
+  getOrphanedSummary(orphaned) {
+    const total = orphaned.assistants.length + orphaned.datasources.length + orphaned.workflows.length;
+    if (total === 0) {
+      return "No orphaned resources found";
+    }
+    const parts = [];
+    if (orphaned.assistants.length > 0) {
+      parts.push(`${orphaned.assistants.length} assistant(s)`);
+    }
+    if (orphaned.datasources.length > 0) {
+      parts.push(`${orphaned.datasources.length} datasource(s)`);
+    }
+    if (orphaned.workflows.length > 0) {
+      parts.push(`${orphaned.workflows.length} workflow(s)`);
+    }
+    return `Found ${total} orphaned resource(s): ${parts.join(", ")}`;
+  }
+};
+
+// src/lib/paginationUtils.ts
+async function findResourceByName(listFn, name, resourceType) {
+  let page = 0;
+  const perPage = 100;
+  let totalChecked = 0;
+  while (true) {
+    const resources = await listFn({ page, per_page: perPage });
+    totalChecked += resources.length;
+    const found = resources.find((r) => r.name === name);
+    if (found && found.id) {
+      return found;
+    }
+    if (resources.length < perPage) {
+      logger.warn(
+        `  \u26A0\uFE0F  ${resourceType} "${name}" not found after checking ${totalChecked} resources across ${page + 1} page(s)`
+      );
+      return null;
+    }
+    page++;
+    if (page > 1e3) {
+      logger.warn(`  \u26A0\uFE0F  Stopped pagination after 1000 pages (${totalChecked} resources checked)`);
+      return null;
+    }
+  }
+}
+async function findDatasourceByName(client, name) {
+  const datasource = await findResourceByName((params) => client.datasources.list(params), name, "datasource");
+  return datasource?.id || null;
+}
+async function findAssistantByName(client, name) {
+  const assistant = await findResourceByName((params) => client.assistants.list(params), name, "assistant");
+  return assistant?.id || null;
+}
+
+// src/lib/assistantHelpers.ts
+async function createAssistantAndGetId(client, params, slug) {
+  await client.assistants.create(params);
+  if (slug) {
+    const created = await client.assistants.getBySlug(slug);
+    if (!created?.id) {
+      throw new Error(`Assistant created but not found by slug: ${slug}`);
+    }
+    return created.id;
+  }
+  const assistantId = await findAssistantByName(client, params.name);
+  if (!assistantId) {
+    throw new Error(`Assistant created but not found by name: ${params.name}`);
+  }
+  return assistantId;
+}
+
+// src/lib/typeGuards.ts
+function hasName(obj) {
+  return typeof obj === "object" && obj !== null && "name" in obj;
+}
+function hasSettingId(obj) {
+  return typeof obj === "object" && obj !== null && "setting_id" in obj;
+}
+function isResolvedIntegration(obj) {
+  return typeof obj === "object" && obj !== null && "id" in obj && typeof obj.id === "string";
+}
+
+// src/lib/converters.ts
+function validateMcpCommandArgs(s, hasTopLevelCommand) {
+  if (hasTopLevelCommand) {
+    return true;
+  }
+  const config = s.config;
+  const configArgs = config.args;
+  if (!Array.isArray(configArgs)) {
+    return false;
+  }
+  return configArgs.every((arg) => typeof arg === "string");
+}
+function isValidMcpServer(server) {
+  if (!server || typeof server !== "object") {
+    return false;
+  }
+  const s = server;
+  if (typeof s.name !== "string" || s.name.length === 0) {
+    return false;
+  }
+  const hasTopLevelCommand = typeof s.command === "string" && s.command.length > 0;
+  const hasConfigCommand = s.config && typeof s.config === "object" && typeof s.config.command === "string" && s.config.command.length > 0;
+  const hasCommand = hasTopLevelCommand || hasConfigCommand;
+  const hasTopLevelUrl = typeof s.mcp_connect_url === "string" && s.mcp_connect_url.length > 0;
+  const hasConfigUrl = s.config && typeof s.config === "object" && typeof s.config.url === "string" && s.config.url.length > 0;
+  const hasUrl = hasTopLevelUrl || hasConfigUrl;
+  const hasSettings = s.settings != null;
+  if (hasCommand && hasUrl) {
+    return false;
+  }
+  if (!hasCommand && !hasUrl && !hasSettings) {
+    return false;
+  }
+  if (hasCommand && !validateMcpCommandArgs(s, hasTopLevelCommand)) {
+    return false;
+  }
+  if (s.description != null && typeof s.description !== "string") {
+    return false;
+  }
+  if (s.enabled !== void 0 && typeof s.enabled !== "boolean") {
+    return false;
+  }
+  return true;
+}
+function convertMcpServers(servers) {
+  if (!servers || servers.length === 0) {
+    return void 0;
+  }
+  const validServers = servers.filter((server) => isValidMcpServer(server));
+  if (validServers.length === 0) {
+    return void 0;
+  }
+  return validServers;
+}
+function hasValidCodeStructure(code) {
+  if (!code || typeof code !== "object") {
+    return false;
+  }
+  const c = code;
+  return typeof c.link === "string" && c.link.length > 0;
+}
+function assistantResponseToResource(assistant) {
+  const slug = assistant.slug || "";
+  const promptFileName = slug || assistant.name.toLowerCase().replaceAll(/\s+/g, "-");
+  const mcpServers = convertMcpServers(assistant.mcp_servers);
+  const nestedAssistants = assistant.nested_assistants;
+  const subAssistants = nestedAssistants?.map((nested) => nested.name);
+  const categoriesRaw = assistant.categories;
+  let categories;
+  if (categoriesRaw && Array.isArray(categoriesRaw)) {
+    if (categoriesRaw.length === 0) {
+      categories = [];
+    } else if (typeof categoriesRaw[0] === "object" && categoriesRaw[0] !== null && "id" in categoriesRaw[0]) {
+      categories = categoriesRaw.map((cat) => cat.id);
+    } else {
+      categories = categoriesRaw;
+    }
+  }
+  return {
+    name: assistant.name,
+    description: assistant.description || "",
+    prompt: `system_prompts/${promptFileName}.prompt.md`,
+    model: assistant.llm_model_type || DEFAULT_LLM_MODEL,
+    ...assistant.temperature !== void 0 && assistant.temperature !== null && { temperature: assistant.temperature },
+    ...assistant.top_p !== void 0 && assistant.top_p !== null && { top_p: assistant.top_p },
+    ...assistant.shared !== void 0 && { shared: assistant.shared },
+    ...assistant.is_react !== void 0 && { is_react: assistant.is_react },
+    ...assistant.is_global !== void 0 && { is_global: assistant.is_global },
+    ...assistant.icon_url && { icon_url: assistant.icon_url },
+    ...assistant.conversation_starters && { conversation_starters: assistant.conversation_starters },
+    ...assistant.toolkits && { toolkits: assistant.toolkits },
+    ...assistant.context && { context: assistant.context },
+    ...mcpServers && { mcp_servers: mcpServers },
+    ...subAssistants && { sub_assistants: subAssistants },
+    ...assistant.prompt_variables && { prompt_variables: assistant.prompt_variables },
+    ...categories && { categories }
+  };
+}
+function convertCodeDatasource(datasource, base) {
+  const desc = datasource.description || "";
+  if (hasValidCodeStructure(datasource.code)) {
+    return {
+      ...base,
+      type: "code",
+      description: desc,
+      link: datasource.code.link,
+      branch: datasource.code.branch,
+      index_type: datasource.code.indexType,
+      summarization_model: datasource.code.summarizationModel,
+      files_filter: datasource.code.filesFilter
+    };
+  }
+  return {
+    ...base,
+    type: "code",
+    description: desc,
+    link: void 0
+  };
+}
+function datasourceResponseToResource(datasource, integrationAlias) {
+  const settingId = integrationAlias ? `$ref:imported.integrations.${integrationAlias}.id` : datasource.setting_id ?? "";
+  const allowedWithoutSettingId = /* @__PURE__ */ new Set(["knowledge_base_file", "llm_routing_google"]);
+  if (!settingId && !allowedWithoutSettingId.has(datasource.type)) {
+    logger.warn(`\u26A0\uFE0F  Datasource "${datasource.name}" is missing setting_id (integration reference)`);
+  }
+  const base = {
+    name: datasource.name,
+    type: datasource.type,
+    embeddings_model: datasource.embeddings_model,
+    setting_id: settingId || void 0,
+    shared_with_project: datasource.shared_with_project
+  };
+  if (datasource.type === DataSourceType.CODE) {
+    return convertCodeDatasource(datasource, base);
+  }
+  if (datasource.type === DataSourceType.CONFLUENCE && datasource.confluence) {
+    return {
+      ...base,
+      type: DataSourceType.CONFLUENCE,
+      description: datasource.description || "",
+      ...datasource.confluence
+    };
+  }
+  if (datasource.type === DataSourceType.JIRA && datasource.jira) {
+    return {
+      ...base,
+      type: DataSourceType.JIRA,
+      description: datasource.description || "",
+      ...datasource.jira
+    };
+  }
+  if (datasource.type === DataSourceType.GOOGLE && datasource.google_doc_link) {
+    return {
+      ...base,
+      type: DataSourceType.GOOGLE,
+      description: datasource.description || "",
+      google_doc: datasource.google_doc_link
+    };
+  }
+  if (datasource.type === DataSourceType.FILE) {
+    return {
+      ...base,
+      type: DataSourceType.FILE,
+      description: datasource.description || ""
+    };
+  }
+  logger.warn(`    \u26A0\uFE0F  Unknown datasource type '${datasource.type}' - saving with basic fields only`);
+  return {
+    ...base,
+    description: datasource.description || ""
+  };
+}
+function workflowResponseToResource(workflow) {
+  return {
+    name: workflow.name,
+    description: workflow.description || "",
+    definition: `workflows/${workflow.name.toLowerCase().replaceAll(/\s+/g, "-")}.yaml`,
+    ...workflow.mode && { mode: workflow.mode },
+    ...workflow.shared !== void 0 && { shared: workflow.shared },
+    ...workflow.icon_url && { icon_url: workflow.icon_url }
+  };
+}
+function isValidCodeParams(params) {
+  return typeof params === "object" && params !== null && "link" in params && typeof params.link === "string" && params.link.length > 0;
+}
+function datasourceResourceToCreateParams(datasource, projectName) {
+  const {
+    $ref: _ref,
+    force_reindex: _forceReindex,
+    ...sdkFields
+  } = datasource;
+  const params = {
+    ...sdkFields,
+    project_name: projectName,
+    shared_with_project: datasource.shared_with_project ?? true
+  };
+  if (datasource.type === "code" && !isValidCodeParams(params)) {
+    throw new Error(
+      `Invalid code datasource "${datasource.name}": missing required field "link". Please add repository URL to datasource configuration.`
+    );
+  } else if (datasource.type === "knowledge_base_confluence" && (!("cql" in params) || !params.cql)) {
+    throw new Error(
+      `Invalid Confluence datasource "${datasource.name}": missing required field "cql". Please add CQL query to datasource configuration.`
+    );
+  } else if (datasource.type === "knowledge_base_jira" && (!("jql" in params) || !params.jql)) {
+    throw new Error(
+      `Invalid Jira datasource "${datasource.name}": missing required field "jql". Please add JQL query to datasource configuration.`
+    );
+  } else if (datasource.type === "llm_routing_google" && (!("google_doc" in params) || !params.google_doc)) {
+    throw new Error(
+      `Invalid Google Docs datasource "${datasource.name}": missing required field "google_doc". Please add Google Doc ID to datasource configuration.`
+    );
+  }
+  return params;
+}
+function iacToolToSdk(tool) {
+  return {
+    ...tool,
+    settings_config: tool.settings_config ?? Boolean(tool.settings),
+    settings: isResolvedIntegration(tool.settings) ? tool.settings : void 0
+  };
+}
+function iacToolkitToSdk(toolkit) {
+  return {
+    ...toolkit,
+    settings_config: toolkit.settings_config ?? Boolean(toolkit.settings),
+    is_external: toolkit.is_external ?? false,
+    tools: toolkit.tools.map((tool) => iacToolToSdk(tool)),
+    settings: isResolvedIntegration(toolkit.settings) ? toolkit.settings : void 0
+  };
+}
+function iacMcpServerToSdk(mcp) {
+  return {
+    ...mcp,
+    enabled: mcp.enabled ?? true,
+    settings: isResolvedIntegration(mcp.settings) ? mcp.settings : void 0,
+    mcp_connect_auth_token: isResolvedIntegration(mcp.mcp_connect_auth_token) ? mcp.mcp_connect_auth_token : void 0
+  };
+}
+function assistantResourceToCreateParams(assistant, projectName, promptContent) {
+  const {
+    prompt: _prompt,
+    config: _config,
+    model,
+    sub_assistants: _subAssistants,
+    datasource_names: _datasourceNames,
+    toolkits,
+    mcp_servers: mcpServers,
+    ...sdkFields
+  } = assistant;
+  return {
+    ...sdkFields,
+    project: projectName,
+    llm_model_type: model,
+    system_prompt: promptContent,
+    name: assistant.name,
+    description: assistant.description,
+    conversation_starters: assistant.conversation_starters || [],
+    toolkits: (toolkits || []).map((toolkit) => iacToolkitToSdk(toolkit)),
+    context: assistant.context || [],
+    mcp_servers: (mcpServers || []).map((mcp) => iacMcpServerToSdk(mcp)),
+    assistant_ids: assistant.assistant_ids || [],
+    shared: assistant.shared ?? true,
+    prompt_variables: assistant.prompt_variables || []
+  };
+}
+
+// src/lib/resourceExistenceChecker.ts
+async function checkResourceExists(getState, getResource) {
+  const existingState = getState();
+  if (!existingState) {
+    return false;
+  }
+  try {
+    await getResource(existingState.id);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkAssistantExists(client, name, stateManager) {
+  return checkResourceExists(
+    () => stateManager.getAssistantState(name),
+    (id) => client.assistants.get(id)
+  );
+}
+function checkDatasourceExists(client, name, stateManager) {
+  return checkResourceExists(
+    () => stateManager.getDatasourceState(name),
+    (id) => client.datasources.get(id)
+  );
+}
+function checkWorkflowExists(client, name, stateManager) {
+  return checkResourceExists(
+    () => stateManager.getWorkflowState(name),
+    (id) => client.workflows.get(id)
+  );
+}
+
+// src/deploy.ts
+function sortAssistantsByDependencies(assistants) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const assistantMap = /* @__PURE__ */ new Map();
+  for (const assistant of assistants) {
+    assistantMap.set(assistant.name, assistant);
+  }
+  function visit(name) {
+    if (visited.has(name)) {
+      return;
+    }
+    if (visiting.has(name)) {
+      throw new Error(`Circular dependency detected for assistant: ${name}`);
+    }
+    visiting.add(name);
+    const assistant = assistantMap.get(name);
+    if (assistant && assistant.sub_assistants) {
+      for (const subName of assistant.sub_assistants) {
+        if (!assistantMap.has(subName)) {
+          throw new Error(
+            `Sub-assistant "${subName}" referenced by "${name}" not found in config. Ensure all sub-assistants are defined in resources.assistants.`
+          );
+        }
+        visit(subName);
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    if (assistant) {
+      sorted.push(assistant);
+    }
+  }
+  for (const assistant of assistants) {
+    visit(assistant.name);
+  }
+  return sorted;
+}
+async function deployAssistants(config, client, loader, stateManager) {
+  const stats = { created: 0, updated: 0, unchanged: 0, failed: 0 };
+  if (!config.resources.assistants) {
+    return stats;
+  }
+  logger.info("\u{1F916} Processing assistants...\n");
+  const sortedAssistants = sortAssistantsByDependencies(config.resources.assistants);
+  logger.info(`   Sorted ${sortedAssistants.length} assistant(s) by dependencies
+`);
+  for (const assistant of sortedAssistants) {
+    try {
+      logger.info(`Processing: ${assistant.name}`);
+      const promptContent = loader.loadPrompt(assistant.prompt);
+      let buildConfig = null;
+      if (assistant.config) {
+        buildConfig = loader.loadAssistantConfig(assistant.config);
+      }
+      const configChecksum = calculateAssistantConfigChecksum(assistant, buildConfig);
+      let resolvedAssistantIds = assistant.assistant_ids || [];
+      if (assistant.sub_assistants && assistant.sub_assistants.length > 0) {
+        logger.info(`  Resolving ${assistant.sub_assistants.length} sub-assistant name(s)...`);
+        const resolvedIds = [];
+        for (const name of assistant.sub_assistants) {
+          const subAssistantState = stateManager.getAssistantState(name);
+          if (!subAssistantState) {
+            throw new Error(`Sub-assistant "${name}" not found in state. Ensure the assistant is deployed first.`);
+          }
+          resolvedIds.push(subAssistantState.id);
+          logger.info(`    \u2713 Resolved "${name}" \u2192 ${subAssistantState.id}`);
+        }
+        resolvedAssistantIds = resolvedIds;
+      }
+      let resolvedContext = assistant.context || [];
+      if (assistant.datasource_names && assistant.datasource_names.length > 0) {
+        logger.info(`  Resolving ${assistant.datasource_names.length} datasource name(s)...`);
+        const datasourceContextEntries = [];
+        const datasourcesInConfig = config.resources.datasources || [];
+        const importedDatasources = config.imported?.datasources || [];
+        const allDatasources = [...datasourcesInConfig, ...importedDatasources];
+        for (const dsName of assistant.datasource_names) {
+          const datasource = allDatasources.find((ds) => ds.name === dsName);
+          if (!datasource) {
+            throw new Error(`Datasource with name "${dsName}" not found in config (resources or imported)`);
+          }
+          const contextType = datasource.type === "code" ? "code" : "knowledge_base";
+          datasourceContextEntries.push({
+            context_type: contextType,
+            name: datasource.name
+          });
+          logger.info(`    \u2713 Resolved "${dsName}" \u2192 ${datasource.name} (${contextType})`);
+        }
+        resolvedContext = [...resolvedContext, ...datasourceContextEntries];
+      }
+      const assistantWithResolved = {
+        ...assistant,
+        assistant_ids: resolvedAssistantIds,
+        context: resolvedContext
+      };
+      const apiParams = assistantResourceToCreateParams(assistantWithResolved, config.project.name, promptContent);
+      const existingState = stateManager.getAssistantState(assistant.name);
+      if (existingState) {
+        const existsOnPlatform = await checkAssistantExists(client, assistant.name, stateManager);
+        if (existsOnPlatform) {
+          const hasChanged = existingState.promptChecksum !== calculateChecksum(promptContent) || existingState.configChecksum !== configChecksum;
+          if (hasChanged) {
+            logger.info(`  Updating assistant (ID: ${existingState.id})...`);
+            if (process.env.DEBUG_API) {
+              logger.debug("\n=== DEBUG: Update API Params ===");
+              logger.debug(JSON.stringify(apiParams, null, 2));
+              logger.debug("================================\n");
+            }
+            await client.assistants.update(existingState.id, apiParams);
+            logger.info(`\u2713 Updated assistant: ${assistant.name} (${existingState.id})`);
+            stateManager.updateAssistantState(assistant.name, existingState.id, promptContent, assistant, buildConfig);
+            stats.updated++;
+          } else {
+            logger.info(`  \u2713 No changes detected (ID: ${existingState.id})`);
+            stats.unchanged++;
+          }
+        } else {
+          logger.info(`  \u26A0\uFE0F  Assistant ID from state not found on platform, will create new`);
+          logger.info(`  Creating new assistant...`);
+          if (process.env.DEBUG_API) {
+            logger.debug("\n=== DEBUG: API Params ===");
+            logger.debug(JSON.stringify(apiParams, null, 2));
+            logger.debug("=========================\n");
+          }
+          const assistantId = await createAssistantAndGetId(client, apiParams, assistant.slug);
+          logger.info(`\u2713 Created assistant: ${assistant.name} (${assistantId})`);
+          stateManager.updateAssistantState(assistant.name, assistantId, promptContent, assistant, buildConfig);
+          stats.created++;
+        }
+      } else {
+        logger.info(`  Creating new assistant...`);
+        if (process.env.DEBUG_API) {
+          logger.debug("\n=== DEBUG: API Params ===");
+          logger.debug(JSON.stringify(apiParams, null, 2));
+          logger.debug("=========================\n");
+        }
+        const assistantId = await createAssistantAndGetId(client, apiParams, assistant.slug);
+        logger.info(`\u2713 Created assistant: ${assistant.name} (${assistantId})`);
+        stateManager.updateAssistantState(assistant.name, assistantId, promptContent, assistant, buildConfig);
+        stats.created++;
+      }
+      logger.info("");
+    } catch (error) {
+      logger.error(`  \u274C Failed to deploy ${assistant.name}:`);
+      if (error instanceof Error) {
+        logger.error(`     ${error.message}`);
+        logger.debug(`     Stack:`, error.stack);
+        if ("response" in error) {
+          const axiosError = error;
+          logger.error(`     Status: ${axiosError.response?.status}`);
+          logger.error(`     Data:`, JSON.stringify(axiosError.response?.data, null, 2));
+        }
+      } else {
+        logger.error(`     ${String(error)}`);
+      }
+      logger.info("");
+      stats.failed++;
+    }
+  }
+  return stats;
+}
+async function createDatasourceAndGetId(client, createParams, datasourceName) {
+  await client.datasources.create(createParams);
+  logger.info(`\u2713 Created datasource: ${datasourceName}`);
+  logger.info(`  Fetching datasource ID...`);
+  const datasourceId = await findDatasourceByName(client, datasourceName);
+  if (!datasourceId) {
+    throw new Error(`Datasource created but not found by name: ${datasourceName}`);
+  }
+  logger.info(`  Found ID: ${datasourceId}`);
+  return datasourceId;
+}
+async function deployDatasources(config, client, stateManager) {
+  const stats = { created: 0, updated: 0, unchanged: 0, failed: 0 };
+  logger.info("\u{1F4CA} Processing datasources...\n");
+  if (!config.resources.datasources) {
+    return stats;
+  }
+  for (const datasource of config.resources.datasources) {
+    try {
+      logger.info(`Processing: ${datasource.name}`);
+      const configChecksum = calculateDatasourceConfigChecksum(datasource);
+      const createParams = datasourceResourceToCreateParams(datasource, config.project.name);
+      const existingState = stateManager.getDatasourceState(datasource.name);
+      if (existingState) {
+        const existsOnPlatform = await checkDatasourceExists(client, datasource.name, stateManager);
+        if (existsOnPlatform) {
+          const hasChanged = existingState.configChecksum !== configChecksum;
+          if (hasChanged || datasource.force_reindex) {
+            if (datasource.force_reindex && !hasChanged) {
+              logger.info(`  Force reindexing datasource (ID: ${existingState.id})...`);
+            } else {
+              logger.info(`  Updating datasource (ID: ${existingState.id})...`);
+            }
+            const updateParams = {
+              ...createParams,
+              ...datasource.force_reindex && { full_reindex: true }
+            };
+            await client.datasources.update(updateParams);
+            logger.info(
+              `\u2713 ${datasource.force_reindex && !hasChanged ? "Reindexed" : "Updated"} datasource: ${datasource.name} (${existingState.id})`
+            );
+            stateManager.updateDatasourceState(datasource.name, existingState.id, datasource);
+            stats.updated++;
+          } else {
+            logger.info(`  \u2713 No changes detected (ID: ${existingState.id})`);
+            stats.unchanged++;
+          }
+        } else {
+          logger.info(`  \u26A0\uFE0F  Datasource ID from state not found on platform, will create new`);
+          logger.info(`  Creating new datasource...`);
+          const datasourceId = await createDatasourceAndGetId(client, createParams, datasource.name);
+          stateManager.updateDatasourceState(datasource.name, datasourceId, datasource);
+          stats.created++;
+        }
+      } else {
+        logger.info(`  Creating new datasource...`);
+        const datasourceId = await createDatasourceAndGetId(client, createParams, datasource.name);
+        stateManager.updateDatasourceState(datasource.name, datasourceId, datasource);
+        stats.created++;
+      }
+      logger.info("");
+    } catch (error) {
+      logger.error(`  \u274C Failed to deploy ${datasource.name}:`);
+      if (error instanceof Error) {
+        logger.error(`     ${error.message}`);
+        logger.debug(`     Stack:`, error.stack);
+        if ("response" in error) {
+          const axiosError = error;
+          logger.error(`     Status: ${axiosError.response?.status}`);
+          logger.error(`     Data:`, JSON.stringify(axiosError.response?.data, null, 2));
+        }
+      } else {
+        logger.error(`     ${String(error)}`);
+      }
+      logger.info("");
+      stats.failed++;
+    }
+  }
+  return stats;
+}
+async function deployWorkflows(config, client, stateManager, rootDir = process.cwd()) {
+  const stats = { created: 0, updated: 0, unchanged: 0, failed: 0 };
+  logger.info("\u{1F504} Processing workflows...\n");
+  if (!config.resources.workflows) {
+    return stats;
+  }
+  for (const workflow of config.resources.workflows) {
+    try {
+      logger.info(`Processing: ${workflow.name}`);
+      const yamlPath = path.join(rootDir, workflow.definition);
+      if (!fs.existsSync(yamlPath)) {
+        throw new Error(`Workflow definition file not found: ${workflow.definition}`);
+      }
+      const yamlConfigContent = fs.readFileSync(yamlPath, "utf8");
+      const workflowYaml = yaml.parse(yamlConfigContent);
+      const referencesToResolve = [];
+      for (const assistant of workflowYaml.assistants) {
+        const isInline = !assistant.assistant_name && assistant.model && assistant.system_prompt;
+        if (isInline) {
+          logger.info(`  Skipping inline assistant: ${assistant.id}`);
+          continue;
+        }
+        if (!assistant.assistant_id) {
+          let resolvedId;
+          if (assistant.assistant_name) {
+            const assistantState = stateManager.getAssistantState(assistant.assistant_name);
+            if (assistantState) {
+              resolvedId = assistantState.id;
+              logger.info(`  Resolved (name): ${assistant.assistant_name} \u2192 ${resolvedId.slice(0, 8)}...`);
+            } else {
+              const importedAssistant = config.imported?.assistants?.find(
+                (a) => a.name === assistant.assistant_name
+              );
+              if (importedAssistant && importedAssistant.id) {
+                resolvedId = importedAssistant.id;
+                logger.info(`  Resolved (imported): ${assistant.assistant_name} \u2192 ${resolvedId.slice(0, 8)}...`);
+              } else {
+                throw new Error(
+                  `Assistant "${assistant.assistant_name}" not found in state or imported. Ensure the assistant is deployed first or added to imported.assistants.`
+                );
+              }
+            }
+          } else {
+            throw new Error(`Workflow assistant reference must have 'assistant_name' (local id: ${assistant.id})`);
+          }
+          assistant.assistant_id = resolvedId;
+          const referenceName = assistant.assistant_name;
+          delete assistant.assistant_name;
+          referencesToResolve.push({
+            localId: assistant.id,
+            reference: referenceName || assistant.id,
+            uuid: resolvedId
+          });
+        }
+      }
+      const yamlConfig = yaml.stringify(workflowYaml);
+      const workflowYamlChecksum = calculateChecksum(yamlConfigContent);
+      const configChecksum = calculateWorkflowConfigChecksum(workflow);
+      const existingState = stateManager.getWorkflowState(workflow.name);
+      if (existingState) {
+        const existsOnPlatform = await checkWorkflowExists(client, workflow.name, stateManager);
+        if (existsOnPlatform) {
+          const hasChanged = existingState.workflowYamlChecksum !== workflowYamlChecksum || existingState.configChecksum !== configChecksum;
+          if (hasChanged) {
+            const apiParams = {
+              project: config.project.name,
+              name: workflow.name,
+              description: workflow.description,
+              yaml_config: yamlConfig,
+              mode: workflow.mode,
+              shared: workflow.shared,
+              icon_url: workflow.icon_url
+            };
+            if (process.env.DEBUG_API) {
+              logger.debug("\n=== DEBUG: API Params ===");
+              logger.debug(JSON.stringify(apiParams, null, 2));
+              logger.debug("=========================\n");
+            }
+            logger.info(`  Updating workflow (ID: ${existingState.id})...`);
+            await client.workflows.update(existingState.id, apiParams);
+            logger.info(`\u2713 Updated workflow: ${workflow.name} (${existingState.id})`);
+            stateManager.updateWorkflowState(workflow.name, existingState.id, workflowYamlChecksum, configChecksum);
+            stats.updated++;
+          } else {
+            logger.info(`  \u2713 No changes detected (ID: ${existingState.id})`);
+            stats.unchanged++;
+          }
+        } else {
+          logger.info(`  \u26A0\uFE0F  Workflow ID from state not found on platform, will create new`);
+          logger.info(`  Creating new workflow...`);
+          const apiParams = {
+            project: config.project.name,
+            name: workflow.name,
+            description: workflow.description,
+            yaml_config: yamlConfig,
+            mode: workflow.mode || "Sequential",
+            shared: workflow.shared ?? true,
+            icon_url: workflow.icon_url
+          };
+          if (process.env.DEBUG_API) {
+            logger.debug("\n=== DEBUG: API Params ===");
+            logger.debug(JSON.stringify(apiParams, null, 2));
+            logger.debug("=========================\n");
+          }
+          const result = await client.workflows.create(apiParams);
+          const workflowId = result.data?.id || result.id;
+          if (!workflowId) {
+            throw new Error("Workflow created but ID not returned");
+          }
+          logger.info(`\u2713 Created workflow: ${workflow.name} (${workflowId})`);
+          stateManager.updateWorkflowState(workflow.name, workflowId, workflowYamlChecksum, configChecksum);
+          stats.created++;
+        }
+      } else {
+        logger.info(`  Creating new workflow...`);
+        const apiParams = {
+          project: config.project.name,
+          name: workflow.name,
+          description: workflow.description,
+          yaml_config: yamlConfig,
+          mode: workflow.mode || "Sequential",
+          shared: workflow.shared ?? true,
+          icon_url: workflow.icon_url
+        };
+        if (process.env.DEBUG_API) {
+          logger.debug("\n=== DEBUG: API Params ===");
+          logger.debug(JSON.stringify(apiParams, null, 2));
+          logger.debug("=========================\n");
+        }
+        const result = await client.workflows.create(apiParams);
+        const workflowId = result.data?.id || result.id;
+        if (!workflowId) {
+          throw new Error("Workflow created but ID not returned");
+        }
+        logger.info(`\u2713 Created workflow: ${workflow.name} (${workflowId})`);
+        stateManager.updateWorkflowState(workflow.name, workflowId, workflowYamlChecksum, configChecksum);
+        stats.created++;
+      }
+      logger.info("");
+    } catch (error) {
+      logger.error(`  \u274C Failed to deploy ${workflow.name}:`);
+      if (error instanceof Error) {
+        logger.error(`     ${error.message}`);
+        logger.debug(`     Stack:`, error.stack);
+        if ("response" in error) {
+          const axiosError = error;
+          logger.error(`     Status: ${axiosError.response?.status}`);
+          logger.error(`     Data:`, JSON.stringify(axiosError.response?.data, null, 2));
+        }
+      } else {
+        logger.error(`     ${String(error)}`);
+      }
+      logger.info("");
+      stats.failed++;
+    }
+  }
+  return stats;
+}
+async function deployResources(options) {
+  logger.info("\u{1F680} Deploying resources to Codemie...\n");
+  try {
+    const { appConfig, prune = false } = options;
+    const loader = new CodemieConfigLoader(appConfig);
+    const stateManager = new StateManager(appConfig);
+    logger.info("\u{1F4C4} Loading configuration...");
+    const config = loader.loadConfig();
+    logger.info(`\u2713 Loaded config for project: ${config.project.name}
+`);
+    logger.info("\u{1F50C} Connecting to Codemie API...");
+    const client = await createClient(config);
+    logger.info("\u2713 Connected to Codemie API\n");
+    logger.info("\u{1F9F9} Checking for orphaned resources...");
+    const cleanupManager = new CleanupManager(client, stateManager);
+    const orphaned = cleanupManager.findOrphanedResources(config);
+    const totalOrphaned = orphaned.assistants.length + orphaned.datasources.length + orphaned.workflows.length;
+    let deleted = 0;
+    if (totalOrphaned > 0) {
+      logger.info(`
+\u26A0\uFE0F  Found ${totalOrphaned} orphaned resource(s):`);
+      if (orphaned.assistants.length > 0) {
+        logger.info(`   \u2022 ${orphaned.assistants.length} assistant(s)`);
+      }
+      if (orphaned.datasources.length > 0) {
+        logger.info(`   \u2022 ${orphaned.datasources.length} datasource(s)`);
+      }
+      if (orphaned.workflows.length > 0) {
+        logger.info(`   \u2022 ${orphaned.workflows.length} workflow(s)`);
+      }
+      if (process.env.SAMPLE_DEPLOY === "1") {
+        logger.info("\n\u{1F50E} SAMPLE_DEPLOY=1 -> Skipping orphan deletion (simulation / partial deploy mode)\n");
+      } else if (prune) {
+        logger.info("\n\u{1F5D1}\uFE0F  Deleting orphaned resources (removed from config)...\n");
+        const cleanupResult = await cleanupManager.deleteOrphanedResources(orphaned);
+        deleted = cleanupResult.deleted.assistants.length + cleanupResult.deleted.datasources.length + cleanupResult.deleted.workflows.length;
+        if (deleted > 0) {
+          logger.info(`
+\u2713 Deleted ${deleted} orphaned resource(s)
+`);
+        }
+        if (cleanupResult.errors.length > 0) {
+          logger.info(`
+\u26A0\uFE0F  ${cleanupResult.errors.length} error(s) during cleanup
+`);
+        }
+      } else {
+        logger.info("\n\u26A0\uFE0F  Orphaned resources found but not deleted.");
+        logger.info("   Use --prune flag to delete them.\n");
+      }
+    } else {
+      logger.info("\u2713 No orphaned resources found\n");
+    }
+    let created = 0;
+    let updated = 0;
+    let unchanged = 0;
+    let failed = 0;
+    const datasourceStats = await deployDatasources(config, client, stateManager);
+    created += datasourceStats.created;
+    updated += datasourceStats.updated;
+    unchanged += datasourceStats.unchanged;
+    failed += datasourceStats.failed;
+    const assistantStats = await deployAssistants(config, client, loader, stateManager);
+    created += assistantStats.created;
+    updated += assistantStats.updated;
+    unchanged += assistantStats.unchanged;
+    failed += assistantStats.failed;
+    const workflowStats = await deployWorkflows(config, client, stateManager, appConfig.rootDir);
+    created += workflowStats.created;
+    updated += workflowStats.updated;
+    unchanged += workflowStats.unchanged;
+    failed += workflowStats.failed;
+    logger.info("=".repeat(50));
+    logger.info("\u{1F4CA} Deployment Summary:\n");
+    logger.info(`  \u2705 Created: ${created}`);
+    logger.info(`  \u{1F504} Updated: ${updated}`);
+    logger.info(`  \u{1F4CB} Unchanged: ${unchanged}`);
+    if (deleted > 0) {
+      logger.info(`  \u{1F5D1}\uFE0F  Deleted: ${deleted}`);
+    }
+    if (failed > 0) {
+      logger.info(`  \u274C Failed: ${failed}`);
+    }
+    logger.info("");
+    if (failed > 0) {
+      throw new Error("Deployment completed with errors");
+    } else {
+      logger.info("\u2705 Deployment successful!");
+    }
+  } catch (error) {
+    logger.error("\n\u274C Deployment failed:");
+    logger.error(error instanceof Error ? error.message : String(error));
+    throw error;
+  }
+}
+var DependencyValidator = class {
+  /**
+   * Validate assistant dependencies for cycles and nested sub-assistants
+   */
+  static validateAssistantDependencies(assistants) {
+    const errors = [];
+    const assistantMap = /* @__PURE__ */ new Map();
+    for (const assistant of assistants) {
+      assistantMap.set(assistant.name, assistant);
+    }
+    const cyclicErrors = this.detectCycles(assistants, assistantMap);
+    errors.push(...cyclicErrors);
+    const nestedErrors = this.detectNestedSubAssistants(assistants);
+    errors.push(...nestedErrors);
+    return errors;
+  }
+  /**
+   * Detect cyclic dependencies using DFS (name-based)
+   */
+  static detectCycles(assistants, assistantMap) {
+    const errors = [];
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const dfs = (name, path11) => {
+      if (recursionStack.has(name)) {
+        const cycleStart = path11.indexOf(name);
+        const cycle = [...path11.slice(cycleStart), name];
+        errors.push(`Cyclic dependency detected: ${cycle.join(" \u2192 ")}`);
+        return true;
+      }
+      if (visited.has(name)) {
+        return false;
+      }
+      visited.add(name);
+      recursionStack.add(name);
+      path11.push(name);
+      const assistant = assistantMap.get(name);
+      const subAssistantRefs = assistant?.sub_assistants || [];
+      for (const subRef of subAssistantRefs) {
+        if (!assistantMap.has(subRef)) {
+          continue;
+        }
+        if (dfs(subRef, [...path11])) {
+          return true;
+        }
+      }
+      recursionStack.delete(name);
+      return false;
+    };
+    for (const assistant of assistants) {
+      if (!visited.has(assistant.name)) {
+        dfs(assistant.name, []);
+      }
+    }
+    return errors;
+  }
+  /**
+   * Detect nested sub-assistants (assistant with sub-assistants cannot be a sub-assistant)
+   * Name-based validation
+   */
+  static detectNestedSubAssistants(assistants) {
+    const errors = [];
+    const usedAsSubAssistant = /* @__PURE__ */ new Set();
+    for (const assistant of assistants) {
+      if (assistant.sub_assistants && assistant.sub_assistants.length > 0) {
+        for (const subName of assistant.sub_assistants) {
+          usedAsSubAssistant.add(subName);
+        }
+      }
+    }
+    for (const assistant of assistants) {
+      const hasSubAssistants = assistant.sub_assistants && assistant.sub_assistants.length > 0;
+      if (hasSubAssistants && usedAsSubAssistant.has(assistant.name)) {
+        const parents = [];
+        for (const potentialParent of assistants) {
+          if (potentialParent.sub_assistants?.includes(assistant.name)) {
+            parents.push(potentialParent.name);
+          }
+        }
+        errors.push(
+          `Assistant "${assistant.name}" has sub-assistants but is itself used as a sub-assistant by: ${parents.join(", ")}. Nested sub-assistants are not allowed.`
+        );
+      }
+    }
+    return errors;
+  }
+  /**
+   * Validate workflow assistant references
+   * Check that all assistant_name references in workflows point to existing assistants
+   */
+  static validateWorkflowAssistantReferences(workflows, assistants, importedAssistants) {
+    const errors = [];
+    const availableAssistants = /* @__PURE__ */ new Set();
+    for (const assistant of assistants) {
+      availableAssistants.add(assistant.name);
+    }
+    for (const imported of importedAssistants) {
+      availableAssistants.add(imported.name);
+    }
+    for (const workflow of workflows) {
+      try {
+        const workflowYaml = yaml.parse(workflow.definition);
+        if (!workflowYaml.assistants) {
+          continue;
+        }
+        for (const assistant of workflowYaml.assistants) {
+          if (assistant.model && assistant.system_prompt && !assistant.assistant_name) {
+            continue;
+          }
+          if (assistant.assistant_name && !availableAssistants.has(assistant.assistant_name)) {
+            errors.push(
+              `Workflow "${workflow.name}": Assistant reference "${assistant.assistant_name}" (id: ${assistant.id}) not found in resources.assistants or imported.assistants`
+            );
+          }
+        }
+      } catch (error) {
+        errors.push(
+          `Workflow "${workflow.name}": Failed to parse workflow YAML: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return errors;
+  }
+};
+
+// src/lib/validationUtils.ts
+function isAssistantWithSlug(obj) {
+  return typeof obj === "object" && obj !== null && "slug" in obj && "name" in obj && typeof obj.slug === "string" && typeof obj.name === "string";
+}
+function isAssistant(obj) {
+  return typeof obj === "object" && obj !== null && "id" in obj && "slug" in obj;
+}
+function validateSlugUniqueness(config) {
+  const slugErrors = [];
+  const slugMap = /* @__PURE__ */ new Map();
+  if (config.resources.assistants) {
+    for (const assistant of config.resources.assistants) {
+      if (assistant.slug) {
+        if (!slugMap.has(assistant.slug)) {
+          slugMap.set(assistant.slug, []);
+        }
+        slugMap.get(assistant.slug).push(assistant.name);
+      }
+    }
+  }
+  for (const [slug, names] of slugMap.entries()) {
+    if (names.length > 1) {
+      slugErrors.push(`Duplicate slug "${slug}" for assistants: ${names.join(", ")}`);
+    }
+  }
+  return slugErrors;
+}
+async function checkApiSlugConflicts({
+  config,
+  client,
+  assistantState
+}) {
+  const existingAssistants = await client.assistants.list({
+    minimal_response: false,
+    per_page: 100
+  });
+  const existingSlugs = /* @__PURE__ */ new Map();
+  for (const assistant of existingAssistants) {
+    if (isAssistantWithSlug(assistant) && assistant.slug) {
+      existingSlugs.set(assistant.slug, assistant.name);
+    }
+  }
+  const conflictErrors = [];
+  const iacAssistantNames = new Set(Object.keys(assistantState));
+  if (config.resources.assistants) {
+    for (const assistant of config.resources.assistants) {
+      if (!assistant.slug || iacAssistantNames.has(assistant.name)) {
+        continue;
+      }
+      if (existingSlugs.has(assistant.slug)) {
+        const existingName = existingSlugs.get(assistant.slug);
+        const existingAssistant = existingAssistants.find((a) => isAssistant(a) && a.slug === assistant.slug);
+        conflictErrors.push(
+          `\u274C Slug "${assistant.slug}" for assistant "${assistant.name}" already exists in Codemie
+   Existing assistant: "${existingName}" (ID: ${isAssistant(existingAssistant) ? existingAssistant.id : "unknown"})
+   \u{1F4A1} Change slug to a unique value or omit slug (platform will generate)`
+        );
+      }
+    }
+  }
+  return conflictErrors;
+}
+
+// src/validate.ts
+async function validateConfig(options) {
+  const errors = [];
+  const { checkApi = false, appConfig } = options;
+  const loader = new CodemieConfigLoader(appConfig);
+  const config = loader.loadConfig();
+  const fileValidation = loader.validateFiles(config);
+  if (!fileValidation.valid) {
+    errors.push(...fileValidation.errors);
+  }
+  const slugErrors = validateSlugUniqueness(config);
+  errors.push(...slugErrors);
+  if (config.resources.assistants && config.resources.assistants.length > 0) {
+    const dependencyErrors = DependencyValidator.validateAssistantDependencies(config.resources.assistants);
+    errors.push(...dependencyErrors);
+  }
+  if (config.resources.workflows && config.resources.workflows.length > 0) {
+    const workflowsWithContent = config.resources.workflows.map((workflow) => {
+      const workflowPath = path.resolve(workflow.definition);
+      if (!fs.existsSync(workflowPath)) {
+        errors.push(`Workflow definition file not found: ${workflow.definition}`);
+        return { ...workflow, definition: "" };
+      }
+      const definition = fs.readFileSync(workflowPath, "utf8");
+      return { ...workflow, definition };
+    });
+    const workflowErrors = DependencyValidator.validateWorkflowAssistantReferences(
+      workflowsWithContent,
+      config.resources.assistants || [],
+      config.imported?.assistants || []
+    );
+    errors.push(...workflowErrors);
+  }
+  if (checkApi && errors.length === 0) {
+    const client = await createClient(config);
+    const stateManager = new StateManager(appConfig);
+    const state = stateManager.loadState();
+    const conflictErrors = await checkApiSlugConflicts({ config, client, assistantState: state.resources.assistants });
+    errors.push(...conflictErrors);
+  }
+  return { success: errors.length === 0, errors };
+}
+async function previewResource(resource, resourceType, getState, checkExists, calculateChecksums) {
+  const existingState = getState(resource.name);
+  if (existingState) {
+    const existsOnPlatform = await checkExists();
+    if (existsOnPlatform) {
+      const { hasChanged, updateDetails } = calculateChecksums();
+      return hasChanged ? {
+        type: "update",
+        resourceType,
+        name: resource.name,
+        details: updateDetails
+      } : {
+        type: "no-change",
+        resourceType,
+        name: resource.name
+      };
+    } else {
+      return {
+        type: "create",
+        resourceType,
+        name: resource.name,
+        details: `ID from state not found on platform, will create new`
+      };
+    }
+  } else {
+    const { createDetails } = calculateChecksums();
+    return {
+      type: "create",
+      resourceType,
+      name: resource.name,
+      details: createDetails
+    };
+  }
+}
+function previewOrphanedResources(orphaned, stateManager) {
+  const changes = [];
+  for (const name of orphaned.assistants) {
+    const assistantState = stateManager.getAssistantState(name);
+    changes.push({
+      type: "delete",
+      resourceType: "assistant",
+      name,
+      details: assistantState ? `Removed from config (ID: ${assistantState.id})` : "Removed from config"
+    });
+  }
+  for (const name of orphaned.datasources) {
+    const datasourceState = stateManager.getDatasourceState(name);
+    changes.push({
+      type: "delete",
+      resourceType: "datasource",
+      name,
+      details: datasourceState ? `Removed from config (ID: ${datasourceState.id})` : "Removed from config"
+    });
+  }
+  for (const name of orphaned.workflows) {
+    const workflowState = stateManager.getWorkflowState(name);
+    changes.push({
+      type: "delete",
+      resourceType: "workflow",
+      name,
+      details: workflowState ? `Removed from config (ID: ${workflowState.id})` : "Removed from config"
+    });
+  }
+  return changes;
+}
+async function previewAssistants(assistants, loader, stateManager, client) {
+  const changes = [];
+  for (const assistant of assistants) {
+    const promptContent = loader.loadPrompt(assistant.prompt);
+    let buildConfig = null;
+    if (assistant.config) {
+      buildConfig = loader.loadAssistantConfig(assistant.config);
+    }
+    const configChecksum = calculateAssistantConfigChecksum(assistant, buildConfig);
+    const change = await previewResource(
+      assistant,
+      "assistant",
+      (name) => stateManager.getAssistantState(name),
+      () => checkAssistantExists(client, assistant.name, stateManager),
+      () => {
+        const existingState = stateManager.getAssistantState(assistant.name);
+        const hasChanged = existingState ? existingState.promptChecksum !== calculateChecksum(promptContent) || existingState.configChecksum !== configChecksum : false;
+        return {
+          hasChanged,
+          createDetails: `Model: ${assistant.model}`,
+          updateDetails: "Prompt or configuration changed"
+        };
+      }
+    );
+    changes.push(change);
+  }
+  return changes;
+}
+async function previewDatasources(datasources, stateManager, client) {
+  const changes = [];
+  for (const datasource of datasources) {
+    const change = await previewResource(
+      datasource,
+      "datasource",
+      (name) => stateManager.getDatasourceState(name),
+      () => checkDatasourceExists(client, datasource.name, stateManager),
+      () => {
+        const configChecksum = calculateDatasourceConfigChecksum(datasource);
+        const existingState = stateManager.getDatasourceState(datasource.name);
+        const hasChanged = existingState ? existingState.configChecksum !== configChecksum : false;
+        if (hasChanged || datasource.force_reindex) {
+          return {
+            hasChanged: true,
+            updateDetails: datasource.force_reindex ? "Force reindex" : "Configuration changed"
+          };
+        }
+        return { hasChanged: false };
+      }
+    );
+    if (!change.details && change.type === "create") {
+      change.details = `Type: ${datasource.type}`;
+    }
+    changes.push(change);
+  }
+  return changes;
+}
+async function previewWorkflows(workflows, stateManager, client, rootDir = process.cwd()) {
+  const changes = [];
+  for (const workflow of workflows) {
+    const yamlPath = path.join(rootDir, workflow.definition);
+    if (!fs.existsSync(yamlPath)) {
+      throw new Error(`Workflow definition file not found: ${workflow.definition}`);
+    }
+    const yamlConfig = fs.readFileSync(yamlPath, "utf8");
+    const change = await previewResource(
+      workflow,
+      "workflow",
+      (name) => stateManager.getWorkflowState(name),
+      () => checkWorkflowExists(client, workflow.name, stateManager),
+      () => {
+        const workflowYamlChecksum = calculateChecksum(yamlConfig);
+        const configChecksum = calculateWorkflowConfigChecksum(workflow);
+        const existingState = stateManager.getWorkflowState(workflow.name);
+        const hasChanged = !!existingState && (existingState.workflowYamlChecksum !== workflowYamlChecksum || existingState.configChecksum !== configChecksum);
+        return {
+          hasChanged,
+          ...hasChanged ? { updateDetails: "Workflow YAML or configuration changed" } : {}
+        };
+      }
+    );
+    if (!change.details && change.type === "create") {
+      change.details = `Mode: ${workflow.mode}`;
+    }
+    changes.push(change);
+  }
+  return changes;
+}
+
+// src/preview.ts
+async function previewChanges(appConfig, existingClient) {
+  const loader = new CodemieConfigLoader(appConfig);
+  const stateManager = new StateManager(appConfig);
+  const config = loader.loadConfig();
+  const client = existingClient || await createClient(config);
+  const changes = [];
+  const cleanupManager = new CleanupManager(client, stateManager);
+  const orphaned = cleanupManager.findOrphanedResources(config);
+  changes.push(...previewOrphanedResources(orphaned, stateManager));
+  if (config.resources.assistants) {
+    const assistantChanges = await previewAssistants(config.resources.assistants, loader, stateManager, client);
+    changes.push(...assistantChanges);
+  }
+  if (config.resources.datasources) {
+    const datasourceChanges = await previewDatasources(config.resources.datasources, stateManager, client);
+    changes.push(...datasourceChanges);
+  }
+  if (config.resources.workflows) {
+    const workflowChanges = await previewWorkflows(config.resources.workflows, stateManager, client, appConfig.rootDir);
+    changes.push(...workflowChanges);
+  }
+  const toDelete = changes.filter((c) => c.type === "delete");
+  const toCreate = changes.filter((c) => c.type === "create");
+  const toUpdate = changes.filter((c) => c.type === "update");
+  const unchanged = changes.filter((c) => c.type === "no-change");
+  return {
+    changes,
+    summary: {
+      deleted: toDelete.length,
+      created: toCreate.length,
+      updated: toUpdate.length,
+      unchanged: unchanged.length,
+      total: changes.length
+    }
+  };
+}
+
+// src/lib/constants.ts
+var PAGINATION = {
+  DEFAULT_PAGE_SIZE: 100};
+var TIMEOUTS_MS = {
+  ASSISTANT_FETCH: 3e4,
+  DATASOURCE_FETCH: 3e4,
+  WORKFLOW_FETCH: 3e4,
+  INTEGRATION_FETCH: 3e4
+};
+var RATE_LIMITING = {
+  MAX_CONCURRENT_REQUESTS: 5,
+  RETRY_ATTEMPTS: 3,
+  RETRY_DELAY_MS: 1e3
+};
+var BACKUP = {
+  TEMP_DIR_PREFIX: ".temp-",
+  TRANSACTION_SAVE_TIMEOUT_MS: 5e3
+};
+var BYTES_IN_GB = 1024 ** 3;
+function sanitizeFileName(name, maxLength = 255) {
+  const nameWithHyphens = name.replaceAll(/[/\\]/g, "-");
+  const sanitized = nameWithHyphens.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "").slice(0, maxLength);
+  if (!sanitized) {
+    throw new Error(`Sanitized filename is empty for input: "${name}"`);
+  }
+  return sanitized;
+}
+function validateBackupDirectory(backupDir, minSpaceGB = 1) {
+  try {
+    const parentDir = path.dirname(backupDir);
+    if (!fs.existsSync(parentDir)) {
+      fs.mkdirSync(parentDir, { recursive: true });
+    }
+    const testFile = path.join(parentDir, ".write-test");
+    fs.writeFileSync(testFile, "test");
+    fs.unlinkSync(testFile);
+    try {
+      const stats = fs.statfsSync(parentDir);
+      const availableGB = stats.bavail * stats.bsize / BYTES_IN_GB;
+      if (availableGB < minSpaceGB) {
+        throw new Error(`Insufficient disk space: ${availableGB.toFixed(2)}GB available, need ${minSpaceGB}GB`);
+      }
+    } catch (error) {
+      if (error.code !== "ERR_METHOD_NOT_SUPPORTED") {
+        throw error;
+      }
+    }
+  } catch (error) {
+    throw new Error(`Cannot write to backup directory: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function moveAtomically(tempPath, finalPath) {
+  try {
+    fs.renameSync(tempPath, finalPath);
+  } catch (error) {
+    const err = error;
+    if (err.code === "EEXIST") {
+      throw new Error(`Destination already exists: ${finalPath}`);
+    }
+    throw error;
+  }
+}
+function cleanupDirectory(dirPath) {
+  if (fs.existsSync(dirPath)) {
+    fs.rmSync(dirPath, { recursive: true, force: true });
+  }
+}
+function ensureDirectoryExists(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/lib/backupTransaction.ts
+function busyWaitDelay(ms) {
+}
+var BackupTransaction = class {
+  data;
+  transactionPath;
+  isDirty = false;
+  saveTimer;
+  constructor(backupDir, transactionId) {
+    this.transactionPath = path.join(backupDir, "transaction.json");
+    try {
+      const content = fs.readFileSync(this.transactionPath, "utf8");
+      this.data = JSON.parse(content);
+      logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id}`);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        this.data = this.createNewTransaction(backupDir, transactionId);
+      } else {
+        throw error;
+      }
+    }
+  }
+  createNewTransaction(backupDir, transactionId) {
+    const newData = {
+      id: transactionId || this.generateTransactionId(),
+      status: "in-progress",
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      backupDir,
+      resources: {
+        assistants: { total: 0, completed: [], failed: [] },
+        datasources: { total: 0, completed: [], failed: [] },
+        workflows: { total: 0, completed: [], failed: [] },
+        integrations: { total: 0, completed: [], failed: [] }
+      }
+    };
+    ensureDirectoryExists(this.transactionPath);
+    this.writeTransactionExclusively(newData);
+    return newData;
+  }
+  writeTransactionExclusively(data) {
+    try {
+      const fd = fs.openSync(this.transactionPath, "wx");
+      fs.writeSync(fd, JSON.stringify(data, null, 2));
+      fs.closeSync(fd);
+    } catch (writeError) {
+      const writeErr = writeError;
+      if (writeErr.code === "EEXIST") {
+        this.readWithRetry();
+      } else {
+        throw writeError;
+      }
+    }
+  }
+  readWithRetry() {
+    let retries = 3;
+    let lastReadError;
+    while (retries > 0) {
+      try {
+        const delayMs = 100 * (4 - retries);
+        if (delayMs > 0) {
+          busyWaitDelay(delayMs);
+        }
+        const content = fs.readFileSync(this.transactionPath, "utf8");
+        this.data = JSON.parse(content);
+        logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id} (created by concurrent process)`);
+        break;
+      } catch (readError) {
+        lastReadError = readError instanceof Error ? readError : new Error(String(readError));
+        retries--;
+        if (retries === 0) {
+          throw new Error(
+            `Failed to read transaction file after retries: ${lastReadError.message}. File may be corrupted. Delete ${this.transactionPath} and retry.`
+          );
+        }
+      }
+    }
+  }
+  generateTransactionId() {
+    return crypto.randomBytes(8).toString("hex");
+  }
+  /**
+   * Save transaction state to disk (checkpoint) with timeout protection
+   */
+  async save() {
+    ensureDirectoryExists(this.transactionPath);
+    const savePromise = fs.promises.writeFile(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(
+        () => reject(new Error(`Transaction save timeout after ${BACKUP.TRANSACTION_SAVE_TIMEOUT_MS}ms`)),
+        BACKUP.TRANSACTION_SAVE_TIMEOUT_MS
+      );
+      timeoutId.unref();
+    });
+    try {
+      await Promise.race([savePromise, timeoutPromise]);
+      this.isDirty = false;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      throw new Error(`Failed to save transaction file: ${err.message}`);
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  /**
+   * Internal synchronous save for batching
+   */
+  saveSyncInternal() {
+    ensureDirectoryExists(this.transactionPath);
+    fs.writeFileSync(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
+    this.isDirty = false;
+  }
+  /**
+   * Schedule batched save (debounced to avoid excessive disk writes)
+   */
+  scheduleSave() {
+    if (this.saveTimer) {
+      return;
+    }
+    this.saveTimer = setTimeout(() => {
+      if (this.isDirty) {
+        this.saveSyncInternal();
+      }
+      this.saveTimer = void 0;
+    }, 1e3);
+    this.saveTimer.unref();
+  }
+  /**
+   * Internal method to finalize transaction with a specific status
+   */
+  end(status) {
+    this.data.status = status;
+    this.data.endTime = (/* @__PURE__ */ new Date()).toISOString();
+    this.flush();
+  }
+  /**
+   * Force immediate save (flush pending changes)
+   */
+  flush() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = void 0;
+    }
+    if (this.isDirty) {
+      this.saveSyncInternal();
+    }
+  }
+  /**
+   * Set total count for a resource type
+   */
+  setTotal(resourceType, total) {
+    this.data.resources[resourceType].total = total;
+    this.isDirty = true;
+    this.scheduleSave();
+  }
+  /**
+   * Mark resource as completed
+   */
+  markCompleted(resourceType, resourceId) {
+    if (!this.data.resources[resourceType].completed.includes(resourceId)) {
+      this.data.resources[resourceType].completed.push(resourceId);
+      this.isDirty = true;
+      this.scheduleSave();
+    }
+  }
+  /**
+   * Mark resource as failed
+   */
+  markFailed(resourceType, resourceId, error) {
+    const failedEntry = { id: resourceId, error };
+    const failedList = this.data.resources[resourceType].failed;
+    if (!failedList.some((f) => f.id === resourceId)) {
+      failedList.push(failedEntry);
+      this.isDirty = true;
+      this.scheduleSave();
+    }
+  }
+  /**
+   * Check if resource was already backed up
+   */
+  isCompleted(resourceType, resourceId) {
+    return this.data.resources[resourceType].completed.includes(resourceId);
+  }
+  /**
+   * Mark transaction as completed
+   */
+  complete() {
+    this.end("completed");
+  }
+  /**
+   * Mark transaction as failed
+   */
+  fail() {
+    this.end("failed");
+  }
+  /**
+   * Get transaction data (returns deep copy to prevent external modifications)
+   */
+  getData() {
+    return structuredClone(this.data);
+  }
+  /**
+   * Get summary of backup progress
+   */
+  getSummary() {
+    const { resources } = this.data;
+    const lines = [];
+    for (const [type, data] of Object.entries(resources)) {
+      const completed = data.completed.length;
+      const failed = data.failed.length;
+      const total = data.total;
+      const percent = total > 0 ? Math.round(completed / total * 100) : 0;
+      lines.push(`  ${type}: ${completed}/${total} (${percent}%) ${failed > 0 ? `[${failed} failed]` : ""}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Clean up transaction file after successful completion
+   */
+  cleanup() {
+    if (fs.existsSync(this.transactionPath)) {
+      fs.unlinkSync(this.transactionPath);
+    }
+  }
+};
+function transformIntegrationSettings(settings, integrationIdToAlias, integrationSpecPaths, contextLabel = "integration") {
+  const integrationId = settings.id;
+  const alias = settings.alias || integrationId && integrationIdToAlias.get(integrationId);
+  if (alias) {
+    return { $ref: `imported.integrations.${alias}` };
+  }
+  if (integrationId) {
+    logger.warn(`    \u26A0\uFE0F  No alias found for ${contextLabel} ${integrationId}, keeping full settings`);
+    const specPath = integrationSpecPaths?.get(integrationId);
+    if (specPath && settings.credential_values) {
+      return {
+        ...settings,
+        credential_values: settings.credential_values.map(
+          (cred) => cred.key === "openapi_spec" ? { key: "openapi_spec", value: specPath } : cred
+        )
+      };
+    }
+  }
+  return settings;
+}
+function transformTool(tool, integrationIdToAlias, integrationSpecPaths) {
+  const result = {
+    name: tool.name,
+    settings_config: tool.settings_config
+  };
+  if (tool.label !== void 0 && tool.label !== null) {
+    result.label = tool.label;
+  }
+  if (tool.settings) {
+    result.settings = transformIntegrationSettings(tool.settings, integrationIdToAlias, integrationSpecPaths, "tool");
+  }
+  return result;
+}
+function transformMcpServer(mcp, integrationIdToAlias) {
+  const result = {
+    name: mcp.name,
+    description: mcp.description,
+    enabled: mcp.enabled,
+    command: mcp.command,
+    arguments: mcp.arguments,
+    config: mcp.config,
+    mcp_connect_url: mcp.mcp_connect_url,
+    mcp_connect_auth_token: mcp.mcp_connect_auth_token,
+    tools_tokens_size_limit: mcp.tools_tokens_size_limit
+  };
+  if (mcp.settings && isResolvedIntegration(mcp.settings)) {
+    const alias = mcp.settings.alias || integrationIdToAlias.get(mcp.settings.id);
+    if (alias) {
+      result.settings = { $ref: `imported.integrations.${alias}` };
+    } else {
+      logger.warn(`    \u26A0\uFE0F  No alias found for MCP integration ${mcp.settings.id}, keeping full settings`);
+      result.settings = mcp.settings;
+    }
+  } else if (mcp.settings) {
+    result.settings = mcp.settings;
+  }
+  if (result.mcp_connect_auth_token && isResolvedIntegration(result.mcp_connect_auth_token)) {
+    const authAlias = result.mcp_connect_auth_token.alias || integrationIdToAlias.get(result.mcp_connect_auth_token.id);
+    if (authAlias) {
+      result.mcp_connect_auth_token = { $ref: `imported.integrations.${authAlias}` };
+    } else {
+      logger.warn(
+        `    \u26A0\uFE0F  No alias found for MCP auth token integration ${result.mcp_connect_auth_token.id}, keeping full object`
+      );
+    }
+  }
+  return result;
+}
+function transformToolkits(toolkits, integrationIdToAlias, integrationSpecPaths) {
+  return toolkits?.map(({ toolkit, tools, label, settings_config, is_external, settings }) => ({
+    toolkit,
+    tools: tools.map((tool) => transformTool(tool, integrationIdToAlias, integrationSpecPaths)),
+    label,
+    settings_config,
+    is_external,
+    ...settings ? {
+      settings: transformIntegrationSettings(settings, integrationIdToAlias, integrationSpecPaths, "toolkit")
+    } : {}
+  }));
+}
+function prepareAssistantForYaml(assistant, state, integrationIdToAlias, integrationSpecPaths) {
+  const transformedToolkits = transformToolkits(assistant.toolkits, integrationIdToAlias, integrationSpecPaths);
+  const transformedMcpServers = assistant.mcp_servers?.map((mcp) => transformMcpServer(mcp, integrationIdToAlias));
+  const finalAssistant = {
+    ...assistantResponseToResource(assistant),
+    ...transformedToolkits && { toolkits: transformedToolkits },
+    ...transformedMcpServers && { mcp_servers: transformedMcpServers }
+  };
+  state.resources.assistants[assistant.name] = {
+    id: assistant.id,
+    lastDeployed: (/* @__PURE__ */ new Date()).toISOString(),
+    promptChecksum: calculateChecksum(assistant.system_prompt || ""),
+    configChecksum: calculateAssistantConfigChecksum(finalAssistant)
+  };
+  return finalAssistant;
+}
+function prepareDatasourceForYaml(datasource, state, integrationIdToAlias) {
+  const settingId = hasSettingId(datasource) ? String(datasource.setting_id || "") : "";
+  const integrationAlias = integrationIdToAlias.get(settingId);
+  const finalDatasource = datasourceResponseToResource(datasource, integrationAlias);
+  state.resources.datasources[datasource.name] = {
+    id: datasource.id,
+    lastDeployed: (/* @__PURE__ */ new Date()).toISOString(),
+    configChecksum: calculateDatasourceConfigChecksum(finalDatasource)
+  };
+  return finalDatasource;
+}
+function prepareWorkflowForYaml(workflow, state, assistants, backupDir) {
+  const resource = workflowResponseToResource(workflow);
+  const yamlConfig = workflow.yaml_config;
+  let finalYamlContent = yamlConfig || "";
+  if (yamlConfig) {
+    try {
+      const workflowYaml = yaml.parse(yamlConfig);
+      const transformedAssistants = workflowYaml.assistants?.map((assistant) => {
+        if (assistant.assistant_id && typeof assistant.assistant_id === "string") {
+          const assistantId = assistant.assistant_id;
+          const matchedAssistant = assistants.find(({ id }) => id === assistantId);
+          if (matchedAssistant && hasName(matchedAssistant)) {
+            const { assistant_id: _assistantId, ...rest } = assistant;
+            return { ...rest, assistant_name: matchedAssistant.name };
+          }
+        }
+        return assistant;
+      });
+      if (transformedAssistants) {
+        const transformedYaml = { ...workflowYaml, assistants: transformedAssistants };
+        const fileName = `${sanitizeFileName(workflow.name)}.yaml`;
+        const filePath = path.join(backupDir, "workflows", fileName);
+        ensureDirectoryExists(filePath);
+        finalYamlContent = yaml.stringify(transformedYaml);
+        fs.writeFileSync(filePath, finalYamlContent, "utf8");
+      }
+    } catch (error) {
+      logger.warn(
+        `    \u26A0\uFE0F  Failed to transform workflow YAML for ${workflow.name}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  state.resources.workflows[workflow.name] = {
+    id: workflow.id,
+    lastDeployed: (/* @__PURE__ */ new Date()).toISOString(),
+    workflowYamlChecksum: calculateChecksum(finalYamlContent),
+    configChecksum: calculateWorkflowConfigChecksum(resource)
+  };
+  return resource;
+}
+
+// src/lib/backupYamlGenerator.ts
+function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPaths = /* @__PURE__ */ new Map()) {
+  const integrationIdToAlias = /* @__PURE__ */ new Map();
+  const integrationArray = [];
+  for (const integration of backup.resources.integrations) {
+    const alias = integration.alias || `${integration.credential_type.toLowerCase()}_${integration.id.slice(0, 8)}`;
+    integrationIdToAlias.set(integration.id, alias);
+    const specPath = integrationSpecPaths.get(integration.id);
+    let credentialValues = integration.credential_values;
+    if (specPath && credentialValues) {
+      credentialValues = credentialValues.map(
+        (cred) => cred.key === "openapi_spec" ? { key: "openapi_spec", value: specPath } : cred
+      );
+    }
+    integrationArray.push({
+      id: integration.id,
+      alias,
+      credential_type: integration.credential_type,
+      project_name: integration.project_name,
+      setting_type: integration.setting_type,
+      ...credentialValues && { credential_values: credentialValues }
+    });
+  }
+  const config = {
+    version: "1",
+    project: {
+      name: projectName,
+      description: `Backup from ${backup.metadata.timestamp}`
+    },
+    environment: {
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: Not a template, but exact formatting
+      codemie_api_url: "${CODEMIE_API_URL}",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: Not a template, but exact formatting
+      auth_server_url: "${CODEMIE_AUTH_URL}",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: Not a template, but exact formatting
+      auth_realm_name: "${CODEMIE_REALM:-codemie}",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: Not a template, but exact formatting
+      client_id: "${CODEMIE_CLIENT_ID:-}",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: Not a template, but exact formatting
+      client_secret: "${CODEMIE_CLIENT_SECRET:-}",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: Not a template, but exact formatting
+      username: "${CODEMIE_USERNAME:-}",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: Not a template, but exact formatting
+      password: "${CODEMIE_PASSWORD:-}"
+    },
+    imported: {
+      assistants: [],
+      datasources: [],
+      integrations: integrationArray
+    },
+    datasource_defaults: {
+      code: { type: "code", index_type: "code", embeddings_model: "ada-002", shared_with_project: true },
+      knowledge_base_confluence: {
+        type: "knowledge_base_confluence",
+        embeddings_model: "ada-002",
+        shared_with_project: true
+      },
+      knowledge_base_jira: { type: "knowledge_base_jira", embeddings_model: "ada-002", shared_with_project: true }
+    },
+    resources: {
+      assistants: backup.resources.assistants.map(
+        (assistant) => prepareAssistantForYaml(assistant, backup.state, integrationIdToAlias, integrationSpecPaths)
+      ),
+      datasources: backup.resources.datasources.map(
+        (datasource) => prepareDatasourceForYaml(datasource, backup.state, integrationIdToAlias)
+      ),
+      workflows: backup.resources.workflows.map(
+        (workflow) => prepareWorkflowForYaml(workflow, backup.state, backup.resources.assistants, backupDir)
+      )
+    }
+  };
+  return yaml.stringify(config);
+}
+function saveIntegrationOpenApiSpecs(backupData, backupDir) {
+  const specsDir = path.join(backupDir, "openapi_specs");
+  let specsCount = 0;
+  const integrationSpecPaths = /* @__PURE__ */ new Map();
+  for (const integration of backupData.resources.integrations) {
+    if (integration.credential_type !== "OpenAPI" || !integration.credential_values) {
+      continue;
+    }
+    const specEntry = integration.credential_values.find(
+      (cv) => cv.key === "openapi_spec"
+    );
+    if (specEntry && typeof specEntry.value === "string" && specEntry.value) {
+      const alias = integration.alias || integration.id;
+      const fileName = String(alias).toLowerCase().replaceAll(/[^a-z0-9]+/g, "-");
+      if (!fs.existsSync(specsDir)) {
+        fs.mkdirSync(specsDir, { recursive: true });
+      }
+      const specContent = specEntry.value;
+      let fileExtension = ".yaml";
+      let contentToSave = specContent;
+      try {
+        const parsed = JSON.parse(specContent);
+        fileExtension = ".json";
+        contentToSave = JSON.stringify(parsed, null, 2);
+      } catch {
+        fileExtension = ".yaml";
+      }
+      const specFileName = `${fileName}${fileExtension}`;
+      const specPath = path.join(specsDir, specFileName);
+      fs.writeFileSync(specPath, contentToSave, "utf8");
+      integrationSpecPaths.set(integration.id, `openapi_specs/${specFileName}`);
+      specsCount++;
+    }
+  }
+  if (specsCount > 0) {
+    logger.info(`   \u2713 Saved ${specsCount} integration OpenAPI spec(s)`);
+  }
+  return integrationSpecPaths;
+}
+function saveBackupFiles(backupData, backupDir, projectName) {
+  logger.info("\u{1F4BE} Writing backup files...\n");
+  const integrationSpecPaths = saveIntegrationOpenApiSpecs(backupData, backupDir);
+  const codemieYamlPath = path.join(backupDir, "codemie.yaml");
+  const codemieYaml = generateCodemieYaml(backupData, projectName, backupDir, integrationSpecPaths);
+  fs.writeFileSync(codemieYamlPath, codemieYaml, "utf8");
+  logger.info(`   \u2713 Saved config file: codemie.yaml`);
+  const backupJsonPath = path.join(backupDir, "backup.json");
+  fs.writeFileSync(backupJsonPath, JSON.stringify(backupData, null, 2), "utf8");
+  logger.info(`   \u2713 Saved full backup: backup.json`);
+  const statePath = path.join(backupDir, "state.json");
+  fs.writeFileSync(statePath, JSON.stringify(backupData.state, null, 2), "utf8");
+  logger.info(`   \u2713 Saved state file: state.json`);
+}
+function createConcurrentLimiter(maxConcurrent = RATE_LIMITING.MAX_CONCURRENT_REQUESTS) {
+  return pLimit(maxConcurrent);
+}
+async function withRetry(fn, operation, maxAttempts = RATE_LIMITING.RETRY_ATTEMPTS) {
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const errorMsg = lastError.message.toLowerCase();
+      const isRetryable = lastError.message.includes("429") || errorMsg.includes("too many requests") || /\b5\d{2}\b/.test(lastError.message) || // 5xx HTTP status codes only
+      errorMsg.includes("timeout") || errorMsg.includes("econnreset") || errorMsg.includes("econnrefused");
+      if (!isRetryable || attempt === maxAttempts) {
+        throw lastError;
+      }
+      const delayMs = RATE_LIMITING.RETRY_DELAY_MS * 2 ** (attempt - 1);
+      logger.warn(`   \u26A0\uFE0F  Retry ${attempt}/${maxAttempts} for ${operation} after ${delayMs}ms...`);
+      await new Promise((resolve3) => {
+        const timerId = setTimeout(resolve3, delayMs);
+        timerId.unref();
+      });
+    }
+  }
+  throw lastError || new Error(`Failed after ${maxAttempts} attempts: ${operation}`);
+}
+
+// src/lib/timeoutUtils.ts
+async function withTimeout(promise, timeoutMs, operation) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(`Operation timeout: ${operation} (${timeoutMs}ms)`)), timeoutMs);
+    timeoutId.unref();
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+// src/backup.ts
+async function* streamResources(fetchPage, resourceType) {
+  let page = 0;
+  let hasMore = true;
+  let totalFetched = 0;
+  logger.info(`   Streaming ${resourceType} (with pagination)...`);
+  while (hasMore) {
+    const resources = await fetchPage({
+      per_page: PAGINATION.DEFAULT_PAGE_SIZE,
+      page
+    });
+    if (resources.length === 0) {
+      break;
+    }
+    for (const resource of resources) {
+      totalFetched++;
+      yield resource;
+    }
+    if (resources.length < PAGINATION.DEFAULT_PAGE_SIZE) {
+      hasMore = false;
+    } else {
+      page++;
+      logger.info(`   Streamed ${totalFetched} ${resourceType} so far...`);
+    }
+  }
+}
+async function saveAssistantToBackup(assistant, client, backupData, backupDir) {
+  logger.info(`   \u2022 ${assistant.name} (${assistant.id})`);
+  const full = await withTimeout(
+    client.assistants.get(assistant.id),
+    TIMEOUTS_MS.ASSISTANT_FETCH,
+    `Timeout fetching assistant ${assistant.id}`
+  );
+  backupData.resources.assistants.push(full);
+  if (full.system_prompt) {
+    const fileName = `${full.slug || sanitizeFileName(full.name)}.prompt.md`;
+    const filePath = path.join(backupDir, "system_prompts", fileName);
+    ensureDirectoryExists(filePath);
+    fs.writeFileSync(filePath, full.system_prompt, "utf8");
+  }
+}
+async function backupAssistants(client, backupData, backupDir, transaction) {
+  logger.info("\u{1F916} Fetching assistants...");
+  const allAssistants = [];
+  for await (const assistant of streamResources((params) => client.assistants.list(params), "assistants")) {
+    allAssistants.push(assistant);
+  }
+  logger.info(`   Found ${allAssistants.length} assistant(s)`);
+  transaction.setTotal("assistants", allAssistants.length);
+  const limit = createConcurrentLimiter();
+  for (const assistant of allAssistants) {
+    if (transaction.isCompleted("assistants", assistant.id)) {
+      logger.info(`   \u21B7 Skipping ${assistant.name} (already backed up)`);
+      continue;
+    }
+    try {
+      await limit(
+        () => withRetry(
+          async () => saveAssistantToBackup(assistant, client, backupData, backupDir),
+          `Backup assistant ${assistant.name}`
+        )
+      );
+      transaction.markCompleted("assistants", assistant.id);
+    } catch (error) {
+      const errorDetails = error instanceof Error ? { message: error.message, stack: error.stack, name: error.name } : { message: String(error) };
+      logger.error(`   \u274C Failed to backup ${assistant.name}:`);
+      logger.error(`      ${errorDetails.message}`);
+      if (errorDetails.stack) {
+        logger.error(`      Stack trace: ${errorDetails.stack.split("\n").slice(1, 3).join("\n      ")}`);
+      }
+      transaction.markFailed("assistants", assistant.id, errorDetails.message);
+    }
+  }
+  logger.info(`\u2713 Backed up ${transaction.getData().resources.assistants.completed.length} assistant(s)
+`);
+}
+async function processDatasourceBackup(datasource, client, backupData, transaction) {
+  logger.info(`   \u2022 ${datasource.name} (${datasource.id})`);
+  const full = await withTimeout(
+    client.datasources.get(datasource.id),
+    TIMEOUTS_MS.DATASOURCE_FETCH,
+    `Timeout fetching datasource ${datasource.id}`
+  );
+  backupData.resources.datasources.push(full);
+  transaction.markCompleted("datasources", datasource.id);
+}
+async function backupDatasources(client, backupData, transaction) {
+  logger.info("\u{1F4CA} Fetching datasources...");
+  const datasources = [];
+  for await (const datasource of streamResources((params) => client.datasources.list(params), "datasources")) {
+    datasources.push(datasource);
+  }
+  logger.info(`   Found ${datasources.length} datasource(s)`);
+  transaction.setTotal("datasources", datasources.length);
+  const limit = createConcurrentLimiter();
+  for (const datasource of datasources) {
+    if (transaction.isCompleted("datasources", datasource.id)) {
+      logger.info(`   \u21B7 Skipping ${datasource.name} (already backed up)`);
+      continue;
+    }
+    try {
+      await limit(
+        () => withRetry(
+          async () => processDatasourceBackup(datasource, client, backupData, transaction),
+          `Backup datasource ${datasource.name}`
+        )
+      );
+    } catch (error) {
+      const errorDetails = error instanceof Error ? { message: error.message, stack: error.stack, name: error.name } : { message: String(error) };
+      logger.error(`   \u274C Failed to backup ${datasource.name}:`);
+      logger.error(`      ${errorDetails.message}`);
+      if (errorDetails.stack) {
+        logger.error(`      Stack trace: ${errorDetails.stack.split("\n").slice(1, 3).join("\n      ")}`);
+      }
+      transaction.markFailed("datasources", datasource.id, errorDetails.message);
+    }
+  }
+  logger.info(`\u2713 Backed up ${transaction.getData().resources.datasources.completed.length} datasource(s)
+`);
+}
+async function backupWorkflows(client, backupData, backupDir, transaction) {
+  logger.info("\u{1F504} Fetching workflows...");
+  const workflows = [];
+  for await (const workflow of streamResources((params) => client.workflows.list(params), "workflows")) {
+    workflows.push(workflow);
+  }
+  logger.info(`   Found ${workflows.length} workflow(s)`);
+  transaction.setTotal("workflows", workflows.length);
+  for (const workflow of workflows) {
+    if (transaction.isCompleted("workflows", workflow.id)) {
+      logger.info(`   \u21B7 Skipping ${workflow.name} (already backed up)`);
+      continue;
+    }
+    try {
+      logger.info(`   \u2022 ${workflow.name} (${workflow.id})`);
+      const full = await withTimeout(
+        client.workflows.get(workflow.id),
+        TIMEOUTS_MS.WORKFLOW_FETCH,
+        `Timeout fetching workflow ${workflow.id}`
+      );
+      backupData.resources.workflows.push(full);
+      if (full.yaml_config) {
+        const fileName = `${sanitizeFileName(full.name)}.yaml`;
+        const filePath = path.join(backupDir, "workflows", fileName);
+        ensureDirectoryExists(filePath);
+        fs.writeFileSync(filePath, full.yaml_config, "utf8");
+      }
+      transaction.markCompleted("workflows", workflow.id);
+    } catch (error) {
+      const errorDetails = error instanceof Error ? { message: error.message, stack: error.stack, name: error.name } : { message: String(error) };
+      logger.error(`   \u274C Failed to backup ${workflow.name}:`);
+      logger.error(`      ${errorDetails.message}`);
+      if (errorDetails.stack) {
+        logger.error(`      Stack trace: ${errorDetails.stack.split("\n").slice(1, 3).join("\n      ")}`);
+      }
+      transaction.markFailed("workflows", workflow.id, errorDetails.message);
+    }
+  }
+  logger.info(`\u2713 Backed up ${transaction.getData().resources.workflows.completed.length} workflow(s)
+`);
+}
+async function backupIntegrations(client, backupData) {
+  logger.info("\u{1F50C} Fetching integrations...");
+  const projectIntegrations = await withTimeout(
+    client.integrations.list({
+      per_page: PAGINATION.DEFAULT_PAGE_SIZE,
+      page: 0,
+      setting_type: "project"
+    }),
+    TIMEOUTS_MS.INTEGRATION_FETCH,
+    "Timeout fetching project integrations"
+  );
+  logger.info(`   Found ${projectIntegrations.length} project integration(s)`);
+  for (const integration of projectIntegrations) {
+    logger.info(`   \u2022 ${integration.alias || integration.credential_type} (${integration.id}) [project]`);
+    backupData.resources.integrations.push(integration);
+  }
+  const userIntegrations = await withTimeout(
+    client.integrations.list({
+      per_page: PAGINATION.DEFAULT_PAGE_SIZE,
+      page: 0,
+      setting_type: "user"
+    }),
+    TIMEOUTS_MS.INTEGRATION_FETCH,
+    "Timeout fetching user integrations"
+  );
+  logger.info(`   Found ${userIntegrations.length} user integration(s)`);
+  for (const integration of userIntegrations) {
+    logger.info(`   \u2022 ${integration.alias || integration.credential_type} (${integration.id}) [user]`);
+    backupData.resources.integrations.push(integration);
+  }
+  logger.info(`\u2713 Backed up ${projectIntegrations.length + userIntegrations.length} integration(s)
+`);
+}
+function getUniqueBackupDir(baseDir, timestamp) {
+  let counter = 0;
+  let finalBackupDir = path.join(baseDir, timestamp);
+  while (fs.existsSync(finalBackupDir)) {
+    counter++;
+    finalBackupDir = path.join(baseDir, `${timestamp}-${counter}`);
+  }
+  const dirSuffix = counter > 0 ? `${timestamp}-${counter}` : timestamp;
+  const tempBackupDir = path.join(baseDir, `${BACKUP.TEMP_DIR_PREFIX}${dirSuffix}`);
+  return { finalDir: finalBackupDir, tempDir: tempBackupDir };
+}
+function performCleanup(tempBackupDir, transaction) {
+  if (fs.existsSync(tempBackupDir)) {
+    try {
+      logger.info(`\u{1F9F9} Rolling back: cleaning up ${tempBackupDir}...`);
+      cleanupDirectory(tempBackupDir);
+      logger.info("\u2713 Rollback completed");
+    } catch (cleanupError) {
+      logger.error(
+        "\u26A0\uFE0F  Failed to cleanup backup directory:",
+        cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+      );
+    }
+  }
+  if (transaction) {
+    try {
+      transaction.cleanup();
+      logger.info("\u2713 Transaction file cleaned up");
+    } catch (cleanupError) {
+      logger.error(
+        "\u26A0\uFE0F  Failed to cleanup transaction file:",
+        cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+      );
+    }
+  }
+}
+async function backupResources(options) {
+  logger.info("\u{1F5C4}\uFE0F  Creating backup of all Codemie resources...\n");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "").replaceAll(":", "-");
+  const { appConfig } = options;
+  const { rootDir, backupsDirectory } = appConfig;
+  const backupBaseDir = path.join(rootDir, backupsDirectory);
+  const { finalDir: finalBackupDir, tempDir: tempBackupDir } = getUniqueBackupDir(backupBaseDir, timestamp);
+  let transaction = null;
+  try {
+    validateBackupDirectory(backupBaseDir);
+    const loader = new CodemieConfigLoader(appConfig);
+    const config = loader.loadConfig();
+    logger.info("\u{1F50C} Connecting to Codemie API...");
+    const client = await createClient(config);
+    logger.info("\u2713 Connected to Codemie API\n");
+    if (!fs.existsSync(tempBackupDir)) {
+      fs.mkdirSync(tempBackupDir, { recursive: true });
+    }
+    logger.info(`\u{1F4C1} Temporary backup directory: ${tempBackupDir}
+`);
+    transaction = new BackupTransaction(tempBackupDir);
+    const backupData = {
+      metadata: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        projectName: config.project.name,
+        codemieApiUrl: config.environment.codemie_api_url
+      },
+      resources: {
+        assistants: [],
+        datasources: [],
+        workflows: [],
+        integrations: []
+      },
+      state: {
+        version: "1.0",
+        project: config.project.name,
+        lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+        resources: {
+          assistants: {},
+          datasources: {},
+          workflows: {}
+        }
+      }
+    };
+    await backupAssistants(client, backupData, tempBackupDir, transaction);
+    await backupDatasources(client, backupData, transaction);
+    await backupWorkflows(client, backupData, tempBackupDir, transaction);
+    await backupIntegrations(client, backupData);
+    const stats = transaction.getData();
+    const totalFailed = stats.resources.assistants.failed.length + stats.resources.datasources.failed.length + stats.resources.workflows.failed.length;
+    if (totalFailed > 0) {
+      logger.warn(`
+\u26A0\uFE0F  Backup completed with ${totalFailed} failed resource(s)`);
+      logger.warn("Review transaction.json for details\n");
+      const totalResources = stats.resources.assistants.total + stats.resources.datasources.total + stats.resources.workflows.total;
+      const failureRate = totalResources > 0 ? totalFailed / totalResources * 100 : 0;
+      if (failureRate > 20) {
+        throw new Error(
+          `Too many failures (${totalFailed}/${totalResources} = ${failureRate.toFixed(1)}%), backup aborted`
+        );
+      }
+    }
+    saveBackupFiles(backupData, tempBackupDir, config.project.name);
+    transaction.complete();
+    logger.info(`
+\u{1F504} Finalizing backup...`);
+    moveAtomically(tempBackupDir, finalBackupDir);
+    logger.info(`\u2713 Backup finalized at ${finalBackupDir}
+`);
+    const separator = "=".repeat(50);
+    logger.info(`${separator}`);
+    logger.info("\u{1F4CA} Backup Summary:\n");
+    logger.info(`  \u{1F916} Assistants: ${backupData.resources.assistants.length}`);
+    logger.info(`  \u{1F4CA} Datasources: ${backupData.resources.datasources.length}`);
+    logger.info(`  \u{1F504} Workflows: ${backupData.resources.workflows.length}`);
+    logger.info(`  \u{1F50C} Integrations: ${backupData.resources.integrations.length}`);
+    logger.info(`
+  \u{1F4C1} Location: ${finalBackupDir}
+`);
+    logger.info("\u{1F4C8} Detailed Progress:\n");
+    logger.info(transaction.getSummary());
+    logger.info("");
+    transaction.cleanup();
+    logger.info("\u2705 Backup completed successfully!");
+  } catch (error) {
+    logger.error("\n\u274C Backup failed:");
+    logger.error(error instanceof Error ? error.message : String(error));
+    performCleanup(tempBackupDir, transaction);
+    throw error;
+  }
+}
+async function destroyResources(options) {
+  logger.info("\u{1F5D1}\uFE0F  Destroy all managed resources\n");
+  logger.info("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+  try {
+    const { appConfig, force = false } = options;
+    const loader = new CodemieConfigLoader(appConfig);
+    const stateManager = new StateManager(appConfig);
+    const config = loader.loadConfig();
+    logger.info(`Project: ${config.project.name}
+`);
+    const managed = stateManager.getAllManagedResources();
+    const total = managed.assistants.length + managed.datasources.length + managed.workflows.length;
+    if (total === 0) {
+      logger.info("\u2713 No managed resources found in state\n");
+      logger.info("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+      return;
+    }
+    logger.info(`Found ${total} managed resource(s):
+`);
+    if (managed.assistants.length > 0) {
+      logger.info(`  \u{1F916} Assistants: ${managed.assistants.length}`);
+      for (const name of managed.assistants) {
+        logger.info(`     \u2022 ${name}`);
+      }
+    }
+    if (managed.datasources.length > 0) {
+      logger.info(`  \u{1F4CA} Datasources: ${managed.datasources.length}`);
+      for (const name of managed.datasources) {
+        logger.info(`     \u2022 ${name}`);
+      }
+    }
+    if (managed.workflows.length > 0) {
+      logger.info(`  \u{1F504} Workflows: ${managed.workflows.length}`);
+      for (const name of managed.workflows) {
+        logger.info(`     \u2022 ${name}`);
+      }
+    }
+    logger.warn("\n\u26A0\uFE0F  WARNING: This will DELETE all resources listed above!");
+    logger.warn("\u26A0\uFE0F  These resources were created through IaC (in state.json)\n");
+    logger.info("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+    if (force) {
+      logger.info("\u{1F680} --force flag detected, skipping confirmation\n");
+    } else {
+      const readline = await import('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve3) => {
+        rl.question('Type "destroy" to confirm deletion: ', resolve3);
+      });
+      rl.close();
+      if (answer.trim().toLowerCase() !== "destroy") {
+        logger.info("\n\u274C Destruction cancelled\n");
+        return;
+      }
+    }
+    logger.info("\n\u{1F5D1}\uFE0F  Deleting resources...\n");
+    const client = await createClient(config);
+    const cleanupManager = new CleanupManager(client, stateManager);
+    const result = await cleanupManager.deleteOrphanedResources(managed);
+    const totalDeleted = result.deleted.assistants.length + result.deleted.datasources.length + result.deleted.workflows.length;
+    logger.info("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+    logger.info("\u{1F4CA} Destruction Summary:\n");
+    logger.info(`  \u2705 Deleted: ${totalDeleted}`);
+    if (result.errors.length > 0) {
+      logger.error(`  \u274C Failed: ${result.errors.length}
+`);
+      for (const err of result.errors) {
+        logger.error(`     \u2022 ${err.type} ${err.name}: ${err.error}`);
+      }
+    }
+    logger.info("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+    if (result.errors.length > 0) {
+      throw new Error("Destruction completed with errors");
+    } else {
+      logger.info("\u2705 All managed resources destroyed");
+    }
+  } catch (error) {
+    logger.error("\n\u274C Destruction failed:");
+    logger.error(error instanceof Error ? error.message : String(error));
+    throw error;
+  }
+}
+
+export { CleanupManager, CodemieConfigLoader, LogLevel, StateManager, backupResources, createClient, deployAssistants, deployDatasources, deployResources, deployWorkflows, destroyResources, logger, previewChanges, validateConfig };