@codemieai/cdk 0.1.439 → 0.1.445

package/dist/index.js

@@ -1,12 +1,878 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'yaml';
+import ora from 'ora';
 import * as crypto from 'crypto';
 import { CodeMieClient, DataSourceType } from 'codemie-sdk';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml6 from 'yaml';
 import 'dotenv/config';
 import pLimit from 'p-limit';
+import * as readline from 'readline';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function pauseSpinner(operation) {
+  return spinnerManager.pause(operation);
+}
+function pauseSpinnerWhile(operation) {
+  return spinnerManager.pauseWhile(operation);
+}
+var defaultSpinnerFactory, CommandSpinnerManager, spinnerManager;
+var init_commandSpinner = __esm({
+  "src/lib/commandSpinner.ts"() {
+    defaultSpinnerFactory = (text) => ora({
+      text,
+      discardStdin: false
+    });
+    CommandSpinnerManager = class {
+      spinner = null;
+      spinnerText = "";
+      factory = defaultSpinnerFactory;
+      setFactory(factory) {
+        this.factory = factory;
+      }
+      resetFactory() {
+        this.factory = defaultSpinnerFactory;
+        this.reset();
+      }
+      reset() {
+        if (this.spinner?.isSpinning) {
+          this.spinner.stop();
+        }
+        this.spinner = null;
+        this.spinnerText = "";
+      }
+      isEnabled() {
+        return Boolean(process.stderr?.isTTY);
+      }
+      start(text) {
+        this.spinnerText = text;
+        if (!this.isEnabled()) {
+          return;
+        }
+        if (!this.spinner) {
+          this.spinner = this.factory(text);
+          this.spinner.start();
+          return;
+        }
+        this.spinner.text = text;
+        if (!this.spinner.isSpinning) {
+          this.spinner.start();
+        }
+      }
+      stop() {
+        if (this.spinner?.isSpinning) {
+          this.spinner.stop();
+        }
+      }
+      succeed(text) {
+        if (!this.spinner) {
+          return;
+        }
+        this.spinner.succeed(text ?? this.spinnerText);
+        this.spinner = null;
+        this.spinnerText = "";
+      }
+      fail(text) {
+        if (!this.spinner) {
+          return;
+        }
+        this.spinner.fail(text ?? this.spinnerText);
+        this.spinner = null;
+        this.spinnerText = "";
+      }
+      pause(operation) {
+        const shouldResume = Boolean(this.spinner?.isSpinning);
+        const currentText = this.spinner?.text ?? this.spinnerText;
+        if (shouldResume) {
+          this.spinner?.stop();
+        }
+        try {
+          return operation();
+        } finally {
+          if (shouldResume && this.spinner) {
+            this.spinner.text = currentText;
+            this.spinner.start();
+          }
+        }
+      }
+      async pauseWhile(operation) {
+        const shouldResume = Boolean(this.spinner?.isSpinning);
+        const currentText = this.spinner?.text ?? this.spinnerText;
+        if (shouldResume) {
+          this.spinner?.stop();
+        }
+        try {
+          return await operation();
+        } finally {
+          if (shouldResume && this.spinner) {
+            this.spinner.text = currentText;
+            this.spinner.start();
+          }
+        }
+      }
+    };
+    spinnerManager = new CommandSpinnerManager();
+  }
+});
 
-// src/lib/codemieConfigLoader.ts
+// src/lib/logger.ts
+var LogLevel, Logger, logger;
+var init_logger = __esm({
+  "src/lib/logger.ts"() {
+    init_commandSpinner();
+    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 || {});
+    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 */) {
+          pauseSpinner(() => {
+            console.debug(message, ...args);
+          });
+        }
+      }
+      info(message, ...args) {
+        if (this.level <= 1 /* INFO */) {
+          pauseSpinner(() => {
+            console.log(message, ...args);
+          });
+        }
+      }
+      warn(message, ...args) {
+        if (this.level <= 2 /* WARN */) {
+          pauseSpinner(() => {
+            console.warn(message, ...args);
+          });
+        }
+      }
+      error(message, ...args) {
+        if (this.level <= 3 /* ERROR */) {
+          pauseSpinner(() => {
+            console.error(message, ...args);
+          });
+        }
+      }
+    };
+    logger = Logger.getInstance();
+  }
+});
+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 || [],
+    skills: assistant.skills || [],
+    conversation_starters: assistant.conversation_starters || [],
+    buildConfig
+  };
+}
+function calculateAssistantConfigChecksum(assistant, buildConfig = null) {
+  const normalized = normalizeAssistantConfig(assistant, buildConfig);
+  return calculateChecksum(JSON.stringify(normalized));
+}
+var DEFAULT_LLM_MODEL;
+var init_checksumUtils = __esm({
+  "src/lib/checksumUtils.ts"() {
+    init_logger();
+    DEFAULT_LLM_MODEL = "gpt-4";
+  }
+});
+
+// src/lib/codemieConfigChecksums.ts
+function createExcludeSet(keys) {
+  return new Set(keys);
+}
+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));
+}
+function calculateSkillConfigChecksum(skill) {
+  const filtered = buildChecksumObject(skill, SKILL_EXCLUDED_FIELDS);
+  return calculateChecksum(JSON.stringify(filtered));
+}
+var DATASOURCE_EXCLUDED_FIELDS, WORKFLOW_EXCLUDED_FIELDS, SKILL_EXCLUDED_FIELDS;
+var init_codemieConfigChecksums = __esm({
+  "src/lib/codemieConfigChecksums.ts"() {
+    init_checksumUtils();
+    DATASOURCE_EXCLUDED_FIELDS = createExcludeSet(["force_reindex"]);
+    WORKFLOW_EXCLUDED_FIELDS = createExcludeSet(["definition"]);
+    SKILL_EXCLUDED_FIELDS = createExcludeSet(["file"]);
+  }
+});
+
+// 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";
+}
+var init_typeGuards = __esm({
+  "src/lib/typeGuards.ts"() {
+  }
+});
+function isChunkSummaryType(type) {
+  return CHUNK_SUMMARY_ALIASES.has(type);
+}
+function isFileSummaryType(type) {
+  return FILE_SUMMARY_ALIASES.has(type);
+}
+function normalizeCodeIndexType(datasource) {
+  if (datasource.code?.indexType) {
+    return datasource.code.indexType;
+  }
+  if (datasource.type === DataSourceType.CODE || datasource.type === DataSourceType.SUMMARY) {
+    return datasource.type;
+  }
+  if (datasource.type === DataSourceType.CHUNK_SUMMARY) {
+    return DataSourceType.CHUNK_SUMMARY;
+  }
+  if (isFileSummaryType(datasource.type)) {
+    return DataSourceType.SUMMARY;
+  }
+  if (isChunkSummaryType(datasource.type)) {
+    return DataSourceType.CHUNK_SUMMARY;
+  }
+  return void 0;
+}
+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 assistantResponseToResource(assistant) {
+  const safeName = assistant.name || assistant.id || "assistant";
+  const slug = assistant.slug || "";
+  const promptFileName = slug || String(safeName).toLowerCase().replaceAll(/\s+/g, "-");
+  const mcpServers = convertMcpServers(assistant.mcp_servers);
+  const nestedAssistants = assistant.nested_assistants;
+  const subAssistants = nestedAssistants?.map((nested) => nested.name).filter((name) => Boolean(name));
+  const categories = assistant.categories?.map((category) => category.id);
+  return {
+    name: assistant.name || safeName,
+    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 || "";
+  const indexType = normalizeCodeIndexType(datasource);
+  if (datasource.code) {
+    return {
+      ...base,
+      type: "code",
+      description: desc,
+      link: datasource.code.link,
+      branch: datasource.code.branch,
+      ...indexType && { index_type: indexType },
+      summarization_model: datasource.code.summarizationModel,
+      files_filter: datasource.code.filesFilter
+    };
+  }
+  return {
+    ...base,
+    type: "code",
+    description: desc,
+    ...indexType && { index_type: indexType },
+    link: void 0
+  };
+}
+function datasourceResponseToResource(datasource, integrationAlias) {
+  const isBedrockDatasource = datasource.type === DataSourceType.BEDROCK;
+  const isChunkSummaryDatasource = isChunkSummaryType(datasource.type);
+  const isFileSummaryDatasource = isFileSummaryType(datasource.type);
+  const isCodeFamilyDatasource = datasource.type === DataSourceType.CODE || datasource.type === DataSourceType.SUMMARY || datasource.type === DataSourceType.CHUNK_SUMMARY || isChunkSummaryDatasource || isFileSummaryDatasource;
+  const settingId = integrationAlias ? `$ref:imported.integrations.${integrationAlias}.id` : datasource.setting_id ?? "";
+  const allowedWithoutSettingId = /* @__PURE__ */ new Set([DataSourceType.FILE, DataSourceType.GOOGLE, DataSourceType.BEDROCK]);
+  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 (isCodeFamilyDatasource) {
+    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 || ""
+    };
+  }
+  if (isBedrockDatasource) {
+    return {
+      ...base,
+      type: datasource.type,
+      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) {
+  const safeName = workflow.name || workflow.id || "workflow";
+  return {
+    name: workflow.name || safeName,
+    description: workflow.description || "",
+    definition: `workflows/${String(safeName).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 skillResponseToResource(skill) {
+  const fileName = skill.name.toLowerCase().replaceAll(/\s+/g, "-");
+  return {
+    name: skill.name,
+    description: skill.description || "",
+    file: `skills/${fileName}.skill.md`,
+    ...skill.categories && skill.categories.length > 0 && { categories: skill.categories },
+    ...skill.visibility && skill.visibility !== "project" && { visibility: skill.visibility }
+  };
+}
+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,
+    skills: _skills,
+    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 || []
+  };
+}
+var CHUNK_SUMMARY_ALIASES, FILE_SUMMARY_ALIASES;
+var init_converters = __esm({
+  "src/lib/converters.ts"() {
+    init_checksumUtils();
+    init_logger();
+    init_typeGuards();
+    CHUNK_SUMMARY_ALIASES = /* @__PURE__ */ new Set(["chunk_summary", "chunk-summary"]);
+    FILE_SUMMARY_ALIASES = /* @__PURE__ */ new Set(["file_summary", "file-summary", "file-summay"]);
+  }
+});
+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 });
+  }
+}
+var BYTES_IN_GB;
+var init_fileUtils = __esm({
+  "src/lib/fileUtils.ts"() {
+    BYTES_IN_GB = 1024 ** 3;
+  }
+});
+
+// src/lib/backupTransformers.ts
+var backupTransformers_exports = {};
+__export(backupTransformers_exports, {
+  prepareAssistantForYaml: () => prepareAssistantForYaml,
+  prepareDatasourceForYaml: () => prepareDatasourceForYaml,
+  prepareSkillForYaml: () => prepareSkillForYaml,
+  prepareWorkflowForYaml: () => prepareWorkflowForYaml,
+  transformMcpServer: () => transformMcpServer,
+  transformTool: () => transformTool,
+  transformToolkits: () => transformToolkits
+});
+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, skillIdToName = /* @__PURE__ */ new Map()) {
+  const transformedToolkits = transformToolkits(assistant.toolkits, integrationIdToAlias, integrationSpecPaths);
+  const transformedMcpServers = assistant.mcp_servers?.map((mcp) => transformMcpServer(mcp, integrationIdToAlias));
+  const assistantData = assistant;
+  const resolvedSkillNames = assistantData.skill_ids && assistantData.skill_ids.length > 0 ? assistantData.skill_ids.map((id) => skillIdToName.get(id)).filter((name) => Boolean(name)) : void 0;
+  const finalAssistant = {
+    ...assistantResponseToResource(assistant),
+    ...transformedToolkits && { toolkits: transformedToolkits },
+    ...transformedMcpServers && { mcp_servers: transformedMcpServers },
+    ...resolvedSkillNames && resolvedSkillNames.length > 0 && { skills: resolvedSkillNames }
+  };
+  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 = yaml6.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 = yaml6.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;
+}
+function prepareSkillForYaml(skill, state) {
+  const resource = skillResponseToResource(skill);
+  if (!state.resources.skills) {
+    state.resources.skills = {};
+  }
+  state.resources.skills[skill.name] = {
+    id: skill.id,
+    lastDeployed: (/* @__PURE__ */ new Date()).toISOString(),
+    contentChecksum: calculateChecksum(skill.content || ""),
+    configChecksum: calculateSkillConfigChecksum(resource)
+  };
+  return resource;
+}
+var init_backupTransformers = __esm({
+  "src/lib/backupTransformers.ts"() {
+    init_checksumUtils();
+    init_codemieConfigChecksums();
+    init_converters();
+    init_fileUtils();
+    init_logger();
+    init_typeGuards();
+  }
+});
 var CodemieConfigLoader = class {
   appConfig;
   constructor(appConfig) {
@@ -22,7 +888,7 @@ var CodemieConfigLoader = class {
       throw new Error(`Configuration file not found: ${configPath}`);
     }
     const content = fs.readFileSync(configPath, "utf8");
-    const config = yaml.parse(content);
+    const config = yaml6.parse(content);
     this.resolveImports(config, rootDir);
     this.substituteEnvVars(config);
     this.applyDatasourceDefaults(config);
@@ -41,6 +907,17 @@ var CodemieConfigLoader = class {
     }
     return fs.readFileSync(fullPath, "utf8");
   }
+  /**
+   * Load skill content file (.skill.md)
+   */
+  loadSkillContent(contentPath) {
+    const { rootDir } = this.appConfig;
+    const fullPath = path.join(rootDir, contentPath);
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Skill content file not found: ${fullPath}`);
+    }
+    return fs.readFileSync(fullPath, "utf8");
+  }
   /**
    * Load assistant configuration file
    */
@@ -51,7 +928,7 @@ var CodemieConfigLoader = class {
       throw new Error(`Config file not found: ${fullPath}`);
     }
     const content = fs.readFileSync(fullPath, "utf8");
-    return yaml.parse(content);
+    return yaml6.parse(content);
   }
   /**
    * Validate that all referenced files exist
@@ -79,6 +956,17 @@ var CodemieConfigLoader = class {
         }
       }
     }
+    if (config.resources.skills) {
+      for (const skill of config.resources.skills) {
+        const contentPath = path.join(rootDir, skill.file);
+        if (!fs.existsSync(contentPath)) {
+          errors.push(`Content file not found for skill ${skill.name}: ${skill.file}`);
+        }
+        if (!skill.description) {
+          errors.push(`Missing 'description' for skill: ${skill.name}`);
+        }
+      }
+    }
     return {
       valid: errors.length === 0,
       errors
@@ -175,7 +1063,7 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
     }
     try {
       const content = fs.readFileSync(filePath, "utf8");
-      const parsed = yaml.parse(content);
+      const parsed = yaml6.parse(content);
       if (parsed === null || parsed === void 0) {
         throw new TypeError(`Import file ${filePath} is empty`);
       }
@@ -195,28 +1083,28 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
    * @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 = "") {
+  resolveReferencesRecursive(current, rootConfig, path12 = "") {
     if (!current || typeof current !== "object") {
       return;
     }
     if (Array.isArray(current)) {
-      this.resolveArrayReferences(current, rootConfig, path11);
+      this.resolveArrayReferences(current, rootConfig, path12);
       return;
     }
     if ("$ref" in current && typeof current.$ref === "string") {
-      this.resolveObjectReference(current, rootConfig, path11);
+      this.resolveObjectReference(current, rootConfig, path12);
       return;
     }
-    this.resolveObjectProperties(current, rootConfig, path11);
+    this.resolveObjectProperties(current, rootConfig, path12);
   }
   /**
    * 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) {
+  resolveArrayReferences(arr, rootConfig, path12) {
     const result = arr.flatMap((item, i) => {
-      const contextPath = `${path11}[${i}]`;
+      const contextPath = `${path12}[${i}]`;
       if (!this.isRefObject(item) || item.$ref.startsWith("#")) {
         this.resolveReferencesRecursive(item, rootConfig, contextPath);
         return [item];
@@ -234,9 +1122,9 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
    * Resolve object reference: { $ref: "path" }
    * Replaces object with resolved data (in-place mutation)
    */
-  resolveObjectReference(current, rootConfig, path11) {
+  resolveObjectReference(current, rootConfig, path12) {
     const refPath = current.$ref;
-    const contextPath = path11 || "root";
+    const contextPath = path12 || "root";
     if (refPath.startsWith("#")) {
       return;
     }
@@ -246,24 +1134,24 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
       delete current[key];
     }
     Object.assign(current, filteredResolved);
-    this.resolveReferencesRecursive(current, rootConfig, path11);
+    this.resolveReferencesRecursive(current, rootConfig, path12);
   }
   /**
    * Resolve object properties recursively
    * Handles both nested objects and "$ref:path" string references
    */
-  resolveObjectProperties(current, rootConfig, path11) {
+  resolveObjectProperties(current, rootConfig, path12) {
     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 contextPath = path12 ? `${path12}.${key}` : key;
         const resolved = this.resolveReference(rootConfig, refPath, contextPath);
         current[key] = resolved;
       } else {
-        this.resolveReferencesRecursive(value, rootConfig, path11 ? `${path11}.${key}` : key);
+        this.resolveReferencesRecursive(value, rootConfig, path12 ? `${path12}.${key}` : key);
       }
     }
   }
@@ -402,161 +1290,9 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
   }
 };
 
-// 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
+init_checksumUtils();
+init_codemieConfigChecksums();
 var StateManager = class {
   statePath;
   constructor(appConfig) {
@@ -576,7 +1312,8 @@ var StateManager = class {
       state.resources = {
         assistants: {},
         datasources: {},
-        workflows: {}
+        workflows: {},
+        skills: {}
       };
     }
     if (!state.resources.assistants) {
@@ -588,6 +1325,9 @@ var StateManager = class {
     if (!state.resources.workflows) {
       state.resources.workflows = {};
     }
+    if (!state.resources.skills) {
+      state.resources.skills = {};
+    }
     return state;
   }
   /**
@@ -612,7 +1352,8 @@ var StateManager = class {
       resources: {
         assistants: {},
         datasources: {},
-        workflows: {}
+        workflows: {},
+        skills: {}
       }
     };
   }
@@ -707,19 +1448,20 @@ var StateManager = class {
   }
   /**
    * Get all managed resources (for cleanup/destroy)
-   * Returns: { assistants: [name1, name2], datasources: [name1], workflows: [name1] }
+   * Returns: { assistants: [name1, name2], datasources: [name1], workflows: [name1], skills: [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)
+      workflows: Object.keys(state.resources.workflows),
+      skills: Object.keys(state.resources.skills || {})
     };
   }
   /**
    * Check if a resource is managed by IaC (exists in state.json)
-   * @param type Resource type ('assistant', 'datasource', 'workflow')
+   * @param type Resource type ('assistant', 'datasource', 'workflow', 'skill')
    * @param name Resource name
    */
   isManagedResource(type, name) {
@@ -734,6 +1476,9 @@ var StateManager = class {
       case "workflow": {
         return name in state.resources.workflows;
       }
+      case "skill": {
+        return name in (state.resources.skills || {});
+      }
       default: {
         return false;
       }
@@ -754,11 +1499,47 @@ var StateManager = class {
       case "workflow": {
         return state.resources.workflows[name]?.id;
       }
+      case "skill": {
+        return (state.resources.skills || {})[name]?.id;
+      }
       default: {
         return void 0;
       }
     }
   }
+  /**
+   * Update skill state (keyed by NAME)
+   */
+  updateSkillState(name, id, content, skillResource) {
+    const state = this.loadState();
+    if (!state.resources.skills) {
+      state.resources.skills = {};
+    }
+    state.resources.skills[name] = {
+      id,
+      lastDeployed: (/* @__PURE__ */ new Date()).toISOString(),
+      contentChecksum: calculateChecksum(content),
+      configChecksum: calculateSkillConfigChecksum(skillResource)
+    };
+    this.saveState(state);
+  }
+  /**
+   * Get skill state by NAME
+   */
+  getSkillState(name) {
+    const state = this.loadState();
+    return (state.resources.skills || {})[name];
+  }
+  /**
+   * Delete skill state by NAME
+   */
+  deleteSkillState(name) {
+    const state = this.loadState();
+    if (state.resources.skills) {
+      delete state.resources.skills[name];
+    }
+    this.saveState(state);
+  }
 };
 async function createClient(config) {
   const client = new CodeMieClient({
@@ -771,16 +1552,26 @@ async function createClient(config) {
     password: config.environment.password,
     verify_ssl: true
   });
-  await client.initialize();
+  try {
+    await client.initialize();
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Failed to initialize Codemie client (auth: ${config.environment.auth_server_url}, api: ${config.environment.codemie_api_url}): ${reason}`
+    );
+  }
   return client;
 }
 
 // src/lib/cleanupManager.ts
+init_logger();
 var CleanupManager = class {
   constructor(client, stateManager) {
     this.client = client;
     this.stateManager = stateManager;
   }
+  client;
+  stateManager;
   /**
    * Check if an error indicates that a resource was not found on the platform
    * Handles both proper 404 responses
@@ -821,10 +1612,12 @@ var CleanupManager = class {
     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));
+    const configSkillNames = new Set((config.resources.skills || []).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))
+      workflows: managedResources.workflows.filter((name) => !configWorkflowNames.has(name)),
+      skills: managedResources.skills.filter((name) => !configSkillNames.has(name))
     };
   }
   /**
@@ -838,7 +1631,8 @@ var CleanupManager = class {
       deleted: {
         assistants: [],
         datasources: [],
-        workflows: []
+        workflows: [],
+        skills: []
       },
       errors: []
     };
@@ -907,352 +1701,131 @@ var CleanupManager = class {
         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 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).filter((name) => Boolean(name));
-  const categories = assistant.categories?.map((category) => category.id);
-  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 (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
-    };
+        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)}`
+        );
+      }
+    }
+    for (const name of orphaned.skills || []) {
+      try {
+        if (!this.stateManager.isManagedResource("skill", name)) {
+          logger.info(`  \u26A0\uFE0F  Skipping ${name} - not in state (safety check)`);
+          continue;
+        }
+        const id = this.stateManager.getIdByName("skill", name);
+        if (!id) {
+          logger.info(`  \u26A0\uFE0F  Skipping ${name} - no ID in state`);
+          continue;
+        }
+        await this.deleteResourceSafely("skill", name, id, () => this.client.skills.delete(id));
+        this.stateManager.deleteSkillState(name);
+        result.deleted.skills.push(name);
+      } catch (error) {
+        result.errors.push({
+          type: "skill",
+          name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        logger.error(`  \u274C Failed to delete skill ${name}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    return result;
   }
-  if (datasource.type === DataSourceType.FILE) {
-    return {
-      ...base,
-      type: DataSourceType.FILE,
-      description: datasource.description || ""
-    };
+  /**
+   * Get summary of orphaned resources
+   */
+  getOrphanedSummary(orphaned) {
+    const total = orphaned.assistants.length + orphaned.datasources.length + orphaned.workflows.length + (orphaned.skills?.length ?? 0);
+    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)`);
+    }
+    if ((orphaned.skills?.length ?? 0) > 0) {
+      parts.push(`${orphaned.skills.length} skill(s)`);
+    }
+    return `Found ${total} orphaned resource(s): ${parts.join(", ")}`;
   }
-  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.`
-    );
+};
+
+// src/index.ts
+init_logger();
+
+// src/lib/paginationUtils.ts
+init_logger();
+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;
+    }
   }
-  return params;
 }
-function iacToolToSdk(tool) {
-  return {
-    ...tool,
-    settings_config: tool.settings_config ?? Boolean(tool.settings),
-    settings: isResolvedIntegration(tool.settings) ? tool.settings : void 0
-  };
+async function findDatasourceByName(client, name) {
+  const datasource = await findResourceByName((params) => client.datasources.list(params), name, "datasource");
+  return datasource?.id || null;
 }
-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
-  };
+async function findAssistantByName(client, name) {
+  const assistant = await findResourceByName((params) => client.assistants.list(params), name, "assistant");
+  return assistant?.id || null;
 }
-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
-  };
+async function findSkillByName(client, name) {
+  const skill = await findResourceByName((params) => client.skills.list(params), name, "skill");
+  return skill?.id || null;
 }
-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/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/deploy.ts
+init_checksumUtils();
+init_codemieConfigChecksums();
+init_converters();
+init_logger();
+
 // src/lib/resourceExistenceChecker.ts
 async function checkResourceExists(getState, getResource) {
   const existingState = getState();
@@ -1284,6 +1857,12 @@ function checkWorkflowExists(client, name, stateManager) {
     (id) => client.workflows.get(id)
   );
 }
+function checkSkillExists(client, name, stateManager) {
+  return checkResourceExists(
+    () => stateManager.getSkillState(name),
+    (id) => client.skills.get(id)
+  );
+}
 
 // src/deploy.ts
 function sortAssistantsByDependencies(assistants) {
@@ -1375,69 +1954,268 @@ async function deployAssistants(config, client, loader, stateManager) {
           });
           logger.info(`    \u2713 Resolved "${dsName}" \u2192 ${datasource.name} (${contextType})`);
         }
-        resolvedContext = [...resolvedContext, ...datasourceContextEntries];
+        resolvedContext = [...resolvedContext, ...datasourceContextEntries];
+      }
+      let resolvedSkillIds = [];
+      if (assistant.skills && assistant.skills.length > 0) {
+        logger.info(`  Resolving ${assistant.skills.length} skill name(s)...`);
+        const resolvedIds = [];
+        for (const skillName of assistant.skills) {
+          const skillState = stateManager.getSkillState(skillName);
+          if (!skillState) {
+            throw new Error(`Skill "${skillName}" not found in state. Ensure the skill is deployed first.`);
+          }
+          resolvedIds.push(skillState.id);
+          logger.info(`    \u2713 Resolved "${skillName}" \u2192 ${skillState.id}`);
+        }
+        resolvedSkillIds = resolvedIds;
+      }
+      const assistantWithResolved = {
+        ...assistant,
+        assistant_ids: resolvedAssistantIds,
+        context: resolvedContext,
+        skill_ids: resolvedSkillIds
+      };
+      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");
+          }
+          let assistantId;
+          try {
+            assistantId = await createAssistantAndGetId(client, apiParams, assistant.slug);
+            logger.info(`\u2713 Created assistant: ${assistant.name} (${assistantId})`);
+            stats.created++;
+          } catch (createError) {
+            logger.warn(`  \u26A0\uFE0F  Assistant create failed. Checking if it already exists on platform...`);
+            let existingId = null;
+            if (assistant.slug) {
+              try {
+                const existingBySlug = await client.assistants.getBySlug(assistant.slug);
+                existingId = existingBySlug?.id || null;
+              } catch {
+              }
+            }
+            if (!existingId) {
+              existingId = await findAssistantByName(client, assistant.name);
+            }
+            if (!existingId) {
+              throw createError;
+            }
+            logger.info(`  Found existing assistant ID: ${existingId}. Updating...`);
+            await client.assistants.update(existingId, apiParams);
+            assistantId = existingId;
+            logger.info(`\u2713 Recovered and updated assistant: ${assistant.name} (${assistantId})`);
+            stats.updated++;
+          }
+          stateManager.updateAssistantState(assistant.name, assistantId, promptContent, assistant, buildConfig);
+        }
+      } 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");
+        }
+        let assistantId;
+        try {
+          assistantId = await createAssistantAndGetId(client, apiParams, assistant.slug);
+          logger.info(`\u2713 Created assistant: ${assistant.name} (${assistantId})`);
+          stats.created++;
+        } catch (createError) {
+          logger.warn(`  \u26A0\uFE0F  Assistant create failed. Checking if it already exists on platform...`);
+          let existingId = null;
+          if (assistant.slug) {
+            try {
+              const existingBySlug = await client.assistants.getBySlug(assistant.slug);
+              existingId = existingBySlug?.id || null;
+            } catch {
+            }
+          }
+          if (!existingId) {
+            existingId = await findAssistantByName(client, assistant.name);
+          }
+          if (!existingId) {
+            throw createError;
+          }
+          logger.info(`  Found existing assistant ID: ${existingId}. Updating...`);
+          await client.assistants.update(existingId, apiParams);
+          assistantId = existingId;
+          logger.info(`\u2713 Recovered and updated assistant: ${assistant.name} (${assistantId})`);
+          stats.updated++;
+        }
+        stateManager.updateAssistantState(assistant.name, assistantId, promptContent, assistant, buildConfig);
       }
-      const assistantWithResolved = {
-        ...assistant,
-        assistant_ids: resolvedAssistantIds,
-        context: resolvedContext
-      };
-      const apiParams = assistantResourceToCreateParams(assistantWithResolved, config.project.name, promptContent);
-      const existingState = stateManager.getAssistantState(assistant.name);
+      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 ("statusCode" in error) {
+          const apiError = error;
+          logger.error(`     Status: ${apiError.statusCode}`);
+          logger.error(`     Data: ${JSON.stringify(apiError.response, null, 2)}`);
+        } else 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 deploySkills(config, client, loader, stateManager) {
+  const stats = { created: 0, updated: 0, unchanged: 0, failed: 0 };
+  logger.info("\u{1F3AF} Processing skills...\n");
+  if (!config.resources.skills) {
+    return stats;
+  }
+  for (const skill of config.resources.skills) {
+    try {
+      logger.info(`Processing: ${skill.name}`);
+      const content = loader.loadSkillContent(skill.file);
+      const contentChecksum = calculateChecksum(content);
+      const configChecksum = calculateSkillConfigChecksum(skill);
+      const visibility = skill.visibility ?? "project";
+      const existingState = stateManager.getSkillState(skill.name);
       if (existingState) {
-        const existsOnPlatform = await checkAssistantExists(client, assistant.name, stateManager);
+        const existsOnPlatform = await checkSkillExists(client, skill.name, stateManager);
         if (existsOnPlatform) {
-          const hasChanged = existingState.promptChecksum !== calculateChecksum(promptContent) || existingState.configChecksum !== configChecksum;
+          const hasChanged = existingState.contentChecksum !== contentChecksum || existingState.configChecksum !== configChecksum;
           if (hasChanged) {
-            logger.info(`  Updating assistant (ID: ${existingState.id})...`);
+            logger.info(`  Updating skill (ID: ${existingState.id})...`);
             if (process.env.DEBUG_API) {
               logger.debug("\n=== DEBUG: Update API Params ===");
-              logger.debug(JSON.stringify(apiParams, null, 2));
+              logger.debug(
+                JSON.stringify(
+                  { name: skill.name, description: skill.description, categories: skill.categories },
+                  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);
+            await client.skills.update(existingState.id, {
+              name: skill.name,
+              description: skill.description,
+              content,
+              categories: skill.categories
+            });
+            logger.info(`\u2713 Updated skill: ${skill.name} (${existingState.id})`);
+            stateManager.updateSkillState(skill.name, existingState.id, content, skill);
             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);
+          logger.info(`  \u26A0\uFE0F  Skill ID from state not found on platform, will create new`);
+          logger.info(`  Creating new skill...`);
+          const result = await client.skills.create({
+            name: skill.name,
+            description: skill.description,
+            content,
+            project: config.project.name,
+            visibility,
+            categories: skill.categories
+          });
+          logger.info(`\u2713 Created skill: ${skill.name} (${result.id})`);
+          stateManager.updateSkillState(skill.name, result.id, content, skill);
           stats.created++;
         }
       } else {
-        logger.info(`  Creating new assistant...`);
+        logger.info(`  Creating new skill...`);
         if (process.env.DEBUG_API) {
           logger.debug("\n=== DEBUG: API Params ===");
-          logger.debug(JSON.stringify(apiParams, null, 2));
+          logger.debug(
+            JSON.stringify(
+              { name: skill.name, description: skill.description, visibility, categories: skill.categories },
+              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++;
+        let skillId;
+        try {
+          const result = await client.skills.create({
+            name: skill.name,
+            description: skill.description,
+            content,
+            project: config.project.name,
+            visibility,
+            categories: skill.categories
+          });
+          skillId = result.id;
+          logger.info(`\u2713 Created skill: ${skill.name} (${skillId})`);
+          stats.created++;
+        } catch (createError) {
+          const msg = createError instanceof Error ? createError.message : String(createError);
+          if (!msg.includes("already exists")) {
+            throw createError;
+          }
+          logger.warn(`  \u26A0\uFE0F  Skill already exists on platform (no local state). Fetching ID to recover...`);
+          const existingId = await findSkillByName(client, skill.name);
+          if (!existingId) {
+            throw new Error(`Skill "${skill.name}" reported as existing but could not be found by name.`);
+          }
+          logger.info(`  Found existing skill ID: ${existingId}. Updating...`);
+          await client.skills.update(existingId, {
+            name: skill.name,
+            description: skill.description,
+            content,
+            categories: skill.categories
+          });
+          skillId = existingId;
+          logger.info(`\u2713 Recovered and updated skill: ${skill.name} (${skillId})`);
+          stats.updated++;
+        }
+        stateManager.updateSkillState(skill.name, skillId, content, skill);
       }
       logger.info("");
     } catch (error) {
-      logger.error(`  \u274C Failed to deploy ${assistant.name}:`);
+      logger.error(`  \u274C Failed to deploy ${skill.name}:`);
       if (error instanceof Error) {
         logger.error(`     ${error.message}`);
         logger.debug(`     Stack:`, error.stack);
-        if ("response" in error) {
+        if ("statusCode" in error) {
+          const apiError = error;
+          logger.error(`     Status: ${apiError.statusCode}`);
+          logger.error(`     Data: ${JSON.stringify(apiError.response, null, 2)}`);
+        } else if ("response" in error) {
           const axiosError = error;
           logger.error(`     Status: ${axiosError.response?.status}`);
-          logger.error(`     Data:`, JSON.stringify(axiosError.response?.data, null, 2));
+          logger.error(`     Data: ${JSON.stringify(axiosError.response?.data, null, 2)}`);
         }
       } else {
         logger.error(`     ${String(error)}`);
@@ -1459,6 +2237,24 @@ async function createDatasourceAndGetId(client, createParams, datasourceName) {
   logger.info(`  Found ID: ${datasourceId}`);
   return datasourceId;
 }
+async function createOrRecoverDatasource(client, createParams, datasourceName) {
+  try {
+    return await createDatasourceAndGetId(client, createParams, datasourceName);
+  } catch (createError) {
+    if (createError instanceof Error && createError.message.toLowerCase().includes("already exists")) {
+      logger.warn(`  \u26A0\uFE0F  Datasource "${datasourceName}" already exists on platform. Recovering existing ID...`);
+      const existingId = await findDatasourceByName(client, datasourceName);
+      if (!existingId) {
+        throw new Error(
+          `Datasource "${datasourceName}" already exists but could not be found by name. Manual intervention required.`
+        );
+      }
+      logger.info(`  Found existing ID: ${existingId}`);
+      return existingId;
+    }
+    throw createError;
+  }
+}
 async function deployDatasources(config, client, stateManager) {
   const stats = { created: 0, updated: 0, unchanged: 0, failed: 0 };
   logger.info("\u{1F4CA} Processing datasources...\n");
@@ -1485,12 +2281,24 @@ async function deployDatasources(config, client, stateManager) {
               ...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++;
+            try {
+              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++;
+            } catch (updateError) {
+              if (updateError instanceof Error && updateError.message.includes("unknown not found")) {
+                logger.warn(
+                  `  \u26A0\uFE0F  Datasource "${datasource.name}" update returned 404 \u2014 likely externally managed and read-only. Skipping update.`
+                );
+                stateManager.updateDatasourceState(datasource.name, existingState.id, datasource);
+                stats.unchanged++;
+              } else {
+                throw updateError;
+              }
+            }
           } else {
             logger.info(`  \u2713 No changes detected (ID: ${existingState.id})`);
             stats.unchanged++;
@@ -1498,13 +2306,13 @@ async function deployDatasources(config, client, stateManager) {
         } 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);
+          const datasourceId = await createOrRecoverDatasource(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);
+        const datasourceId = await createOrRecoverDatasource(client, createParams, datasource.name);
         stateManager.updateDatasourceState(datasource.name, datasourceId, datasource);
         stats.created++;
       }
@@ -1542,7 +2350,7 @@ async function deployWorkflows(config, client, stateManager, rootDir = process.c
         throw new Error(`Workflow definition file not found: ${workflow.definition}`);
       }
       const yamlConfigContent = fs.readFileSync(yamlPath, "utf8");
-      const workflowYaml = yaml.parse(yamlConfigContent);
+      const workflowYaml = yaml6.parse(yamlConfigContent);
       const referencesToResolve = [];
       for (const assistant of workflowYaml.assistants) {
         const isInline = !assistant.assistant_name && assistant.model && assistant.system_prompt;
@@ -1583,7 +2391,7 @@ async function deployWorkflows(config, client, stateManager, rootDir = process.c
           });
         }
       }
-      const yamlConfig = yaml.stringify(workflowYaml);
+      const yamlConfig = yaml6.stringify(workflowYaml);
       const workflowYamlChecksum = calculateChecksum(yamlConfigContent);
       const configChecksum = calculateWorkflowConfigChecksum(workflow);
       const existingState = stateManager.getWorkflowState(workflow.name);
@@ -1702,7 +2510,7 @@ async function deployResources(options) {
     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;
+    const totalOrphaned = orphaned.assistants.length + orphaned.datasources.length + orphaned.workflows.length + orphaned.skills.length;
     let deleted = 0;
     if (totalOrphaned > 0) {
       logger.info(`
@@ -1716,12 +2524,15 @@ async function deployResources(options) {
       if (orphaned.workflows.length > 0) {
         logger.info(`   \u2022 ${orphaned.workflows.length} workflow(s)`);
       }
+      if (orphaned.skills.length > 0) {
+        logger.info(`   \u2022 ${orphaned.skills.length} skill(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;
+        deleted = cleanupResult.deleted.assistants.length + cleanupResult.deleted.datasources.length + cleanupResult.deleted.workflows.length + cleanupResult.deleted.skills.length;
         if (deleted > 0) {
           logger.info(`
 \u2713 Deleted ${deleted} orphaned resource(s)
@@ -1748,6 +2559,11 @@ async function deployResources(options) {
     updated += datasourceStats.updated;
     unchanged += datasourceStats.unchanged;
     failed += datasourceStats.failed;
+    const skillStats = await deploySkills(config, client, loader, stateManager);
+    created += skillStats.created;
+    updated += skillStats.updated;
+    unchanged += skillStats.unchanged;
+    failed += skillStats.failed;
     const assistantStats = await deployAssistants(config, client, loader, stateManager);
     created += assistantStats.created;
     updated += assistantStats.updated;
@@ -1804,10 +2620,10 @@ var DependencyValidator = class {
     const errors = [];
     const visited = /* @__PURE__ */ new Set();
     const recursionStack = /* @__PURE__ */ new Set();
-    const dfs = (name, path11) => {
+    const dfs = (name, path12) => {
       if (recursionStack.has(name)) {
-        const cycleStart = path11.indexOf(name);
-        const cycle = [...path11.slice(cycleStart), name];
+        const cycleStart = path12.indexOf(name);
+        const cycle = [...path12.slice(cycleStart), name];
         errors.push(`Cyclic dependency detected: ${cycle.join(" \u2192 ")}`);
         return true;
       }
@@ -1816,14 +2632,14 @@ var DependencyValidator = class {
       }
       visited.add(name);
       recursionStack.add(name);
-      path11.push(name);
+      path12.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])) {
+        if (dfs(subRef, [...path12])) {
           return true;
         }
       }
@@ -1882,7 +2698,7 @@ var DependencyValidator = class {
     }
     for (const workflow of workflows) {
       try {
-        const workflowYaml = yaml.parse(workflow.definition);
+        const workflowYaml = yaml6.parse(workflow.definition);
         if (!workflowYaml.assistants) {
           continue;
         }
@@ -1906,6 +2722,9 @@ var DependencyValidator = class {
   }
 };
 
+// src/validate.ts
+init_logger();
+
 // 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";
@@ -2011,12 +2830,18 @@ async function validateConfig(options) {
   }
   return { success: errors.length === 0, errors };
 }
+init_logger();
+
+// src/lib/previewUtils.ts
+init_checksumUtils();
+init_codemieConfigChecksums();
+init_converters();
 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();
+      const { hasChanged, updateDetails } = await calculateChecksums();
       return hasChanged ? {
         type: "update",
         resourceType,
@@ -2036,7 +2861,7 @@ async function previewResource(resource, resourceType, getState, checkExists, ca
       };
     }
   } else {
-    const { createDetails } = calculateChecksums();
+    const { createDetails } = await calculateChecksums();
     return {
       type: "create",
       resourceType,
@@ -2074,6 +2899,42 @@ function previewOrphanedResources(orphaned, stateManager) {
       details: workflowState ? `Removed from config (ID: ${workflowState.id})` : "Removed from config"
     });
   }
+  for (const name of orphaned.skills || []) {
+    const skillState = stateManager.getSkillState(name);
+    changes.push({
+      type: "delete",
+      resourceType: "skill",
+      name,
+      details: skillState ? `Removed from config (ID: ${skillState.id})` : "Removed from config"
+    });
+  }
+  return changes;
+}
+async function previewSkills(skills, loader, stateManager, client) {
+  const changes = [];
+  for (const skill of skills) {
+    const content = loader.loadSkillContent(skill.file);
+    const contentChecksum = calculateChecksum(content);
+    const configChecksum = calculateSkillConfigChecksum(skill);
+    const change = await previewResource(
+      skill,
+      "skill",
+      (name) => stateManager.getSkillState(name),
+      () => checkSkillExists(client, skill.name, stateManager),
+      () => {
+        const existingState = stateManager.getSkillState(skill.name);
+        const hasChanged = existingState ? existingState.contentChecksum !== contentChecksum || existingState.configChecksum !== configChecksum : false;
+        return {
+          hasChanged,
+          updateDetails: "Content or configuration changed"
+        };
+      }
+    );
+    if (!change.details && change.type === "create") {
+      change.details = skill.visibility === "public" ? "Visibility: public" : "Visibility: project";
+    }
+    changes.push(change);
+  }
   return changes;
 }
 async function previewAssistants(assistants, loader, stateManager, client) {
@@ -2112,10 +2973,19 @@ async function previewDatasources(datasources, stateManager, client) {
       "datasource",
       (name) => stateManager.getDatasourceState(name),
       () => checkDatasourceExists(client, datasource.name, stateManager),
-      () => {
+      async () => {
         const configChecksum = calculateDatasourceConfigChecksum(datasource);
         const existingState = stateManager.getDatasourceState(datasource.name);
-        const hasChanged = existingState ? existingState.configChecksum !== configChecksum : false;
+        let hasChanged = existingState ? existingState.configChecksum !== configChecksum : false;
+        if (hasChanged && existingState?.id) {
+          try {
+            const datasourceOnPlatform = await client.datasources.get(existingState.id);
+            const normalizedPlatformDatasource = datasourceResponseToResource(datasourceOnPlatform);
+            const platformChecksum = calculateDatasourceConfigChecksum(normalizedPlatformDatasource);
+            hasChanged = platformChecksum !== configChecksum;
+          } catch {
+          }
+        }
         if (hasChanged || datasource.force_reindex) {
           return {
             hasChanged: true,
@@ -2174,6 +3044,10 @@ async function previewChanges(appConfig, existingClient) {
   const cleanupManager = new CleanupManager(client, stateManager);
   const orphaned = cleanupManager.findOrphanedResources(config);
   changes.push(...previewOrphanedResources(orphaned, stateManager));
+  if (config.resources.skills) {
+    const skillChanges = await previewSkills(config.resources.skills, loader, stateManager, client);
+    changes.push(...skillChanges);
+  }
   if (config.resources.assistants) {
     const assistantChanges = await previewAssistants(config.resources.assistants, loader, stateManager, client);
     changes.push(...assistantChanges);
@@ -2209,7 +3083,8 @@ var TIMEOUTS_MS = {
   ASSISTANT_FETCH: 3e4,
   DATASOURCE_FETCH: 3e4,
   WORKFLOW_FETCH: 3e4,
-  INTEGRATION_FETCH: 3e4
+  INTEGRATION_FETCH: 3e4,
+  SKILL_FETCH: 3e4
 };
 var RATE_LIMITING = {
   MAX_CONCURRENT_REQUESTS: 5,
@@ -2220,63 +3095,10 @@ 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
+init_fileUtils();
+init_logger();
 function busyWaitDelay(ms) {
 }
 var BackupTransaction = class {
@@ -2309,7 +3131,8 @@ var BackupTransaction = class {
         assistants: { total: 0, completed: [], failed: [] },
         datasources: { total: 0, completed: [], failed: [] },
         workflows: { total: 0, completed: [], failed: [] },
-        integrations: { total: 0, completed: [], failed: [] }
+        integrations: { total: 0, completed: [], failed: [] },
+        skills: { total: 0, completed: [], failed: [] }
       }
     };
     ensureDirectoryExists(this.transactionPath);
@@ -2463,201 +3286,58 @@ var BackupTransaction = class {
     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;
+   * Mark transaction as completed
+   */
+  complete() {
+    this.end("completed");
   }
-  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`
-      );
+  /**
+   * 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");
   }
-  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)}`
-      );
+  /**
+   * Clean up transaction file after successful completion
+   */
+  cleanup() {
+    if (fs.existsSync(this.transactionPath)) {
+      fs.unlinkSync(this.transactionPath);
     }
   }
-  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
+init_backupTransformers();
+init_logger();
 function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPaths = /* @__PURE__ */ new Map()) {
   const integrationIdToAlias = /* @__PURE__ */ new Map();
   const integrationArray = [];
+  const skillIdToName = new Map(backup.resources.skills.map((skill) => [skill.id, skill.name]));
   for (const integration of backup.resources.integrations) {
-    const alias = integration.alias || `${integration.credential_type.toLowerCase()}_${integration.id.slice(0, 8)}`;
+    const credentialType = integration.credential_type || "integration";
+    const alias = integration.alias || `${String(credentialType).toLowerCase()}_${integration.id.slice(0, 8)}`;
     integrationIdToAlias.set(integration.id, alias);
     const specPath = integrationSpecPaths.get(integration.id);
     let credentialValues = integration.credential_values;
@@ -2713,17 +3393,20 @@ function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPath
     },
     resources: {
       assistants: backup.resources.assistants.map(
-        (assistant) => prepareAssistantForYaml(assistant, backup.state, integrationIdToAlias, integrationSpecPaths)
+        (assistant) => prepareAssistantForYaml(assistant, backup.state, integrationIdToAlias, integrationSpecPaths, skillIdToName)
       ),
       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)
-      )
+      ),
+      ...backup.resources.skills.length > 0 && {
+        skills: backup.resources.skills.map((skill) => prepareSkillForYaml(skill, backup.state))
+      }
     }
   };
-  return yaml.stringify(config);
+  return yaml6.stringify(config);
 }
 function saveIntegrationOpenApiSpecs(backupData, backupDir) {
   const specsDir = path.join(backupDir, "openapi_specs");
@@ -2778,6 +3461,11 @@ function saveBackupFiles(backupData, backupDir, projectName) {
   fs.writeFileSync(statePath, JSON.stringify(backupData.state, null, 2), "utf8");
   logger.info(`   \u2713 Saved state file: state.json`);
 }
+
+// src/backup.ts
+init_fileUtils();
+init_logger();
+init_logger();
 function createConcurrentLimiter(maxConcurrent = RATE_LIMITING.MAX_CONCURRENT_REQUESTS) {
   return pLimit(maxConcurrent);
 }
@@ -2797,8 +3485,7 @@ async function withRetry(fn, operation, maxAttempts = RATE_LIMITING.RETRY_ATTEMP
       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();
+        setTimeout(resolve3, delayMs);
       });
     }
   }
@@ -2822,6 +3509,7 @@ async function withTimeout(promise, timeoutMs, operation) {
 }
 
 // src/backup.ts
+init_backupTransformers();
 async function* streamResources(fetchPage, resourceType) {
   let page = 0;
   let hasMore = true;
@@ -2899,21 +3587,42 @@ async function backupAssistants(client, backupData, backupDir, transaction) {
 }
 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}`
-  );
+  let full;
+  try {
+    full = await withTimeout(
+      client.datasources.get(datasource.id),
+      TIMEOUTS_MS.DATASOURCE_FETCH,
+      `Timeout fetching datasource ${datasource.id}`
+    );
+  } catch (error) {
+    logger.warn(
+      `     \u26A0\uFE0F  Failed to fetch full datasource details for ${datasource.name}. Using list response as fallback: ${error instanceof Error ? error.message : String(error)}`
+    );
+    full = datasource;
+  }
   backupData.resources.datasources.push(full);
   transaction.markCompleted("datasources", datasource.id);
 }
-async function backupDatasources(client, backupData, transaction) {
+function normalizeProjectName(projectName) {
+  return String(projectName || "").trim().toLowerCase();
+}
+function filterResourcesByProject(resources, projectName) {
+  const normalized = normalizeProjectName(projectName);
+  if (!normalized) {
+    return resources;
+  }
+  return resources.filter((r) => normalizeProjectName(r?.project_name) === normalized);
+}
+async function backupDatasources(client, backupData, transaction, projectName) {
   logger.info("\u{1F4CA} Fetching datasources...");
-  const datasources = [];
+  const allDatasources = [];
   for await (const datasource of streamResources((params) => client.datasources.list(params), "datasources")) {
-    datasources.push(datasource);
+    allDatasources.push(datasource);
   }
-  logger.info(`   Found ${datasources.length} datasource(s)`);
+  const datasources = filterResourcesByProject(allDatasources, projectName);
+  logger.info(
+    `   Found ${datasources.length} datasource(s) for project '${projectName}' (from ${allDatasources.length} total)`
+  );
   transaction.setTotal("datasources", datasources.length);
   const limit = createConcurrentLimiter();
   for (const datasource of datasources) {
@@ -2982,9 +3691,9 @@ async function backupWorkflows(client, backupData, backupDir, transaction) {
   logger.info(`\u2713 Backed up ${transaction.getData().resources.workflows.completed.length} workflow(s)
 `);
 }
-async function backupIntegrations(client, backupData) {
+async function backupIntegrations(client, backupData, projectName) {
   logger.info("\u{1F50C} Fetching integrations...");
-  const projectIntegrations = await withTimeout(
+  const allProjectIntegrations = await withTimeout(
     client.integrations.list({
       per_page: PAGINATION.DEFAULT_PAGE_SIZE,
       page: 0,
@@ -2993,7 +3702,10 @@ async function backupIntegrations(client, backupData) {
     TIMEOUTS_MS.INTEGRATION_FETCH,
     "Timeout fetching project integrations"
   );
-  logger.info(`   Found ${projectIntegrations.length} project integration(s)`);
+  const projectIntegrations = filterResourcesByProject(allProjectIntegrations, projectName);
+  logger.info(
+    `   Found ${projectIntegrations.length} project integration(s) for project '${projectName}' (from ${allProjectIntegrations.length} total)`
+  );
   for (const integration of projectIntegrations) {
     logger.info(`   \u2022 ${integration.alias || integration.credential_type} (${integration.id}) [project]`);
     backupData.resources.integrations.push(integration);
@@ -3015,6 +3727,50 @@ async function backupIntegrations(client, backupData) {
   logger.info(`\u2713 Backed up ${projectIntegrations.length + userIntegrations.length} integration(s)
 `);
 }
+async function backupSkills(client, backupData, backupDir, transaction) {
+  logger.info("\u{1F9E0} Fetching skills...");
+  const allSkills = [];
+  for await (const skill of streamResources((params) => client.skills.list(params), "skills")) {
+    allSkills.push(skill);
+  }
+  logger.info(`   Found ${allSkills.length} skill(s)`);
+  transaction.setTotal("skills", allSkills.length);
+  const limit = createConcurrentLimiter();
+  for (const skill of allSkills) {
+    if (transaction.isCompleted("skills", skill.id)) {
+      logger.info(`   \u21B7 Skipping ${skill.name} (already backed up)`);
+      continue;
+    }
+    try {
+      await limit(
+        () => withRetry(async () => {
+          logger.info(`   \u2022 ${skill.name} (${skill.id})`);
+          const full = await withTimeout(
+            client.skills.get(skill.id),
+            TIMEOUTS_MS.SKILL_FETCH,
+            `Timeout fetching skill ${skill.id}`
+          );
+          backupData.resources.skills.push(full);
+          const fileName = `${sanitizeFileName(skill.name)}.skill.md`;
+          const filePath = path.join(backupDir, "skills", fileName);
+          ensureDirectoryExists(filePath);
+          fs.writeFileSync(filePath, full.content || "", "utf8");
+        }, `Backup skill ${skill.name}`)
+      );
+      transaction.markCompleted("skills", skill.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 ${skill.name}:`);
+      logger.error(`      ${errorDetails.message}`);
+      if (errorDetails.stack) {
+        logger.error(`      Stack trace: ${errorDetails.stack.split("\n").slice(1, 3).join("\n      ")}`);
+      }
+      transaction.markFailed("skills", skill.id, errorDetails.message);
+    }
+  }
+  logger.info(`\u2713 Backed up ${transaction.getData().resources.skills.completed.length} skill(s)
+`);
+}
 function getUniqueBackupDir(baseDir, timestamp) {
   let counter = 0;
   let finalBackupDir = path.join(baseDir, timestamp);
@@ -3082,7 +3838,8 @@ async function backupResources(options) {
         assistants: [],
         datasources: [],
         workflows: [],
-        integrations: []
+        integrations: [],
+        skills: []
       },
       state: {
         version: "1.0",
@@ -3091,21 +3848,23 @@ async function backupResources(options) {
         resources: {
           assistants: {},
           datasources: {},
-          workflows: {}
+          workflows: {},
+          skills: {}
         }
       }
     };
-    await backupAssistants(client, backupData, tempBackupDir, transaction);
-    await backupDatasources(client, backupData, transaction);
+    await backupSkills(client, backupData, tempBackupDir, transaction);
+    await backupIntegrations(client, backupData, config.project.name);
+    await backupDatasources(client, backupData, transaction, config.project.name);
     await backupWorkflows(client, backupData, tempBackupDir, transaction);
-    await backupIntegrations(client, backupData);
+    await backupAssistants(client, backupData, tempBackupDir, transaction);
     const stats = transaction.getData();
-    const totalFailed = stats.resources.assistants.failed.length + stats.resources.datasources.failed.length + stats.resources.workflows.failed.length;
+    const totalFailed = stats.resources.assistants.failed.length + stats.resources.datasources.failed.length + stats.resources.workflows.failed.length + stats.resources.skills.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 totalResources = stats.resources.assistants.total + stats.resources.datasources.total + stats.resources.workflows.total + stats.resources.skills.total;
       const failureRate = totalResources > 0 ? totalFailed / totalResources * 100 : 0;
       if (failureRate > 20) {
         throw new Error(
@@ -3127,6 +3886,7 @@ async function backupResources(options) {
     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{1F9E0} Skills: ${backupData.resources.skills.length}`);
     logger.info(`
   \u{1F4C1} Location: ${finalBackupDir}
 `);
@@ -3142,6 +3902,356 @@ async function backupResources(options) {
     throw error;
   }
 }
+
+// src/import.ts
+init_converters();
+init_fileUtils();
+init_logger();
+init_checksumUtils();
+init_codemieConfigChecksums();
+var VALID_RESOURCE_TYPES = ["assistant", "datasource", "workflow", "skill"];
+async function findAssistant(client, slug) {
+  try {
+    const assistant = await withTimeout(
+      client.assistants.getBySlug(slug),
+      TIMEOUTS_MS.ASSISTANT_FETCH,
+      `Timeout fetching assistant by slug "${slug}"`
+    );
+    if (assistant) {
+      return assistant;
+    }
+  } catch {
+  }
+  const match = await findResourceByName2((params) => client.assistants.list(params), slug, "assistant");
+  return withTimeout(
+    client.assistants.get(match.id),
+    TIMEOUTS_MS.ASSISTANT_FETCH,
+    `Timeout fetching assistant "${match.id}"`
+  );
+}
+async function findDatasource(client, name) {
+  const match = await findResourceByName2((params) => client.datasources.list(params), name, "datasource");
+  return withTimeout(
+    client.datasources.get(match.id),
+    TIMEOUTS_MS.DATASOURCE_FETCH,
+    `Timeout fetching datasource "${match.id}"`
+  );
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function findWorkflow(client, name) {
+  if (UUID_RE.test(name)) {
+    return withTimeout(client.workflows.get(name), TIMEOUTS_MS.WORKFLOW_FETCH, `Timeout fetching workflow "${name}"`);
+  }
+  let match = null;
+  try {
+    match = await findResourceByName2((params) => client.workflows.list(params), name, "workflow");
+  } catch {
+  }
+  if (match) {
+    return withTimeout(
+      client.workflows.get(match.id),
+      TIMEOUTS_MS.WORKFLOW_FETCH,
+      `Timeout fetching workflow "${match.id}"`
+    );
+  }
+  throw new Error(
+    `workflow "${name}" not found on platform via name search. If you know its ID, pass the UUID directly instead of the name.`
+  );
+}
+async function findSkill(client, name) {
+  const match = await findResourceByName2((params) => client.skills.list(params), name, "skill");
+  return withTimeout(client.skills.get(match.id), TIMEOUTS_MS.SKILL_FETCH, `Timeout fetching skill "${match.id}"`);
+}
+async function findResourceByName2(fetchPage, name, resourceType) {
+  const allResources = [];
+  let page = 0;
+  let hasMore = true;
+  while (hasMore) {
+    const resources = await fetchPage({
+      per_page: PAGINATION.DEFAULT_PAGE_SIZE,
+      page
+    });
+    allResources.push(...resources);
+    if (resources.length < PAGINATION.DEFAULT_PAGE_SIZE) {
+      hasMore = false;
+    } else {
+      page++;
+    }
+  }
+  const lowerName = name.toLowerCase();
+  const matches = allResources.filter((r) => r.name.toLowerCase() === lowerName);
+  if (matches.length === 0) {
+    throw new Error(
+      `${resourceType} "${name}" not found on platform. Found ${allResources.length} ${resourceType}(s) total.`
+    );
+  }
+  if (matches.length > 1) {
+    const names = matches.map((m) => `  - ${m.name} (${m.id})`).join("\n");
+    throw new Error(`Multiple ${resourceType}s matching "${name}" found:
+${names}
+Please use a more specific name.`);
+  }
+  return matches[0];
+}
+function checkResourceExists2(config, resourceType, name) {
+  const pluralType = resourceType === "assistant" ? "assistants" : resourceType === "datasource" ? "datasources" : resourceType === "workflow" ? "workflows" : "skills";
+  const resources = config.resources[pluralType] || [];
+  return resources.some((r) => r.name.toLowerCase() === name.toLowerCase());
+}
+function writeResourceFiles(rootDir, resourceType, resource, apiResponse) {
+  const safeName = sanitizeFileName(resource.name);
+  if (resourceType === "workflow") {
+    const workflow = apiResponse;
+    const workflowResource = resource;
+    if (workflow.yaml_config) {
+      const defFileName = `${safeName}.yaml`;
+      const defPath = path.join(rootDir, "workflows", defFileName);
+      ensureDirectoryExists(defPath);
+      fs.writeFileSync(defPath, workflow.yaml_config, "utf8");
+      logger.info(`   \u{1F4CB} Saved workflow definition: workflows/${defFileName}`);
+      workflowResource.definition = `workflows/${defFileName}`;
+    }
+    const configPath = path.join(rootDir, "configs", "workflows", `${safeName}.yaml`);
+    const relativeConfigPath = `configs/workflows/${safeName}.yaml`;
+    ensureDirectoryExists(configPath);
+    const yamlContent2 = yaml6.stringify(workflowResource, { lineWidth: 120 });
+    fs.writeFileSync(configPath, yamlContent2, "utf8");
+    logger.info(`   \u{1F4C4} Saved workflow config: ${relativeConfigPath}`);
+    return relativeConfigPath;
+  }
+  const pluralType = resourceType === "assistant" ? "assistants" : resourceType === "datasource" ? "datasources" : "skills";
+  const resourceDir = path.join(rootDir, "configs", "imported-resources", pluralType);
+  const resourceFilePath = path.join(resourceDir, `${safeName}.yaml`);
+  const relativeResourcePath = `configs/imported-resources/${pluralType}/${safeName}.yaml`;
+  if (resourceType === "assistant") {
+    const assistant = apiResponse;
+    const assistantResource = resource;
+    if (assistant.system_prompt) {
+      const promptFileName = assistant.slug || safeName;
+      const promptPath = path.join(rootDir, "system_prompts", `${promptFileName}.prompt.md`);
+      ensureDirectoryExists(promptPath);
+      fs.writeFileSync(promptPath, assistant.system_prompt, "utf8");
+      logger.info(`   \u{1F4DD} Saved prompt: system_prompts/${promptFileName}.prompt.md`);
+      assistantResource.prompt = `system_prompts/${promptFileName}.prompt.md`;
+    }
+  } else if (resourceType === "skill") {
+    const skill = apiResponse;
+    const skillResource = resource;
+    if (skill.content) {
+      const skillFileName = `${safeName}.skill.md`;
+      const skillPath = path.join(rootDir, "skills", skillFileName);
+      ensureDirectoryExists(skillPath);
+      fs.writeFileSync(skillPath, skill.content, "utf8");
+      logger.info(`   \u{1F9E0} Saved skill content: skills/${skillFileName}`);
+      skillResource.file = `skills/${skillFileName}`;
+    }
+  }
+  ensureDirectoryExists(resourceFilePath);
+  const yamlContent = yaml6.stringify(resource, { lineWidth: 120 });
+  fs.writeFileSync(resourceFilePath, yamlContent, "utf8");
+  logger.info(`   \u{1F4C4} Saved resource config: ${relativeResourcePath}`);
+  return relativeResourcePath;
+}
+function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relativeResourcePath) {
+  const configPath = path.join(rootDir, codemieConfigPath);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const content = fs.readFileSync(configPath, "utf8");
+  const doc = yaml6.parseDocument(content);
+  const pluralType = resourceType === "assistant" ? "assistants" : resourceType === "datasource" ? "datasources" : resourceType === "workflow" ? "workflows" : "skills";
+  let resourcesNode = doc.get("resources");
+  if (!resourcesNode) {
+    resourcesNode = doc.createNode({});
+    doc.set("resources", resourcesNode);
+  }
+  let typeArray = doc.getIn(["resources", pluralType]);
+  if (!typeArray) {
+    typeArray = doc.createNode([]);
+    doc.setIn(["resources", pluralType], typeArray);
+  }
+  const importDirective = { $import: relativeResourcePath };
+  const existingImports = typeArray.items.filter((item) => {
+    if (yaml6.isMap(item)) {
+      const importValue = item.get("$import");
+      return importValue === relativeResourcePath;
+    }
+    return false;
+  });
+  if (existingImports.length > 0) {
+    logger.info(`   \u21B7 Import directive already exists in ${codemieConfigPath}`);
+    return;
+  }
+  const newNode = doc.createNode(importDirective);
+  typeArray.add(newNode);
+  fs.writeFileSync(configPath, doc.toString(), "utf8");
+  logger.info(`   \u2705 Added $import to ${codemieConfigPath} \u2192 resources.${pluralType}`);
+}
+function updateState(stateManager, resourceType, resource, apiResponse) {
+  switch (resourceType) {
+    case "assistant": {
+      const assistant = apiResponse;
+      const assistantResource = resource;
+      stateManager.updateAssistantState(resource.name, assistant.id, assistant.system_prompt || "", assistantResource);
+      break;
+    }
+    case "datasource": {
+      const datasource = apiResponse;
+      const datasourceResource = resource;
+      stateManager.updateDatasourceState(resource.name, datasource.id, datasourceResource);
+      break;
+    }
+    case "workflow": {
+      const workflow = apiResponse;
+      const workflowResource = resource;
+      stateManager.updateWorkflowState(
+        resource.name,
+        workflow.id,
+        calculateChecksum(workflow.yaml_config || ""),
+        calculateWorkflowConfigChecksum(workflowResource)
+      );
+      break;
+    }
+    case "skill": {
+      const skill = apiResponse;
+      const skillResource = resource;
+      stateManager.updateSkillState(resource.name, skill.id, skill.content || "", skillResource);
+      break;
+    }
+  }
+}
+function buildIntegrationAliasMap(config) {
+  const map = /* @__PURE__ */ new Map();
+  for (const integration of config.imported?.integrations || []) {
+    if (integration.id && integration.alias) {
+      map.set(integration.id, integration.alias);
+    }
+  }
+  return map;
+}
+async function importResource(options) {
+  const { appConfig, resourceType, slug } = options;
+  if (!VALID_RESOURCE_TYPES.includes(resourceType)) {
+    throw new Error(`Invalid resource type: "${resourceType}". Must be one of: ${VALID_RESOURCE_TYPES.join(", ")}`);
+  }
+  const configLoader = new CodemieConfigLoader(appConfig);
+  const config = configLoader.loadConfig();
+  const rootDir = appConfig.rootDir;
+  const stateManager = new StateManager(appConfig);
+  if (checkResourceExists2(config, resourceType, slug)) {
+    throw new Error(
+      `A ${resourceType} named "${slug}" already exists in the configuration. Remove it first or use a different name.`
+    );
+  }
+  logger.info(`
+\u{1F50D} Importing ${resourceType}: "${slug}"
+`);
+  logger.info("   Connecting to CodeMie platform...");
+  const client = await createClient(config);
+  const integrationAliasMap = buildIntegrationAliasMap(config);
+  let resource;
+  let apiResponse;
+  switch (resourceType) {
+    case "assistant": {
+      logger.info(`   Searching for assistant "${slug}"...`);
+      const assistant = await findAssistant(client, slug);
+      logger.info(`   \u2713 Found: ${assistant.name} (${assistant.id})`);
+      apiResponse = assistant;
+      resource = assistantResponseToResource(assistant);
+      if (integrationAliasMap.size > 0) {
+        const { transformToolkits: transformToolkits2, transformMcpServer: transformMcpServer2 } = await Promise.resolve().then(() => (init_backupTransformers(), backupTransformers_exports));
+        const transformedToolkits = transformToolkits2(assistant.toolkits, integrationAliasMap);
+        const transformedMcpServers = assistant.mcp_servers?.map((mcp) => transformMcpServer2(mcp, integrationAliasMap));
+        if (transformedToolkits) {
+          resource.toolkits = transformedToolkits;
+        }
+        if (transformedMcpServers) {
+          resource.mcp_servers = transformedMcpServers;
+        }
+      }
+      const assistantData = assistant;
+      if (assistantData.skill_ids && assistantData.skill_ids.length > 0) {
+        logger.info(`   Resolving ${assistantData.skill_ids.length} skill ID(s)...`);
+        const skillNames = [];
+        for (const skillId of assistantData.skill_ids) {
+          try {
+            const skill = await withTimeout(
+              client.skills.get(skillId),
+              TIMEOUTS_MS.ASSISTANT_FETCH,
+              `Timeout fetching skill "${skillId}"`
+            );
+            skillNames.push(skill.name);
+            logger.info(`     \u2713 Resolved skill ${skillId.slice(0, 8)}... \u2192 "${skill.name}"`);
+          } catch {
+            logger.warn(`     \u26A0\uFE0F  Could not resolve skill ID "${skillId}" \u2014 skipping`);
+          }
+        }
+        if (skillNames.length > 0) {
+          resource.skills = skillNames;
+        }
+      }
+      break;
+    }
+    case "datasource": {
+      logger.info(`   Searching for datasource "${slug}"...`);
+      const datasource = await findDatasource(client, slug);
+      logger.info(`   \u2713 Found: ${datasource.name} (${datasource.id})`);
+      apiResponse = datasource;
+      const settingId = datasource.setting_id || "";
+      const integrationAlias = integrationAliasMap.get(settingId);
+      resource = datasourceResponseToResource(datasource, integrationAlias);
+      break;
+    }
+    case "workflow": {
+      logger.info(`   Searching for workflow "${slug}"...`);
+      const workflow = await findWorkflow(client, slug);
+      logger.info(`   \u2713 Found: ${workflow.name} (${workflow.id})`);
+      if (workflow.name !== slug && checkResourceExists2(config, resourceType, workflow.name)) {
+        throw new Error(
+          `A ${resourceType} named "${workflow.name}" already exists in the configuration. Remove it first or use a different name.`
+        );
+      }
+      apiResponse = workflow;
+      resource = workflowResponseToResource(workflow);
+      break;
+    }
+    case "skill": {
+      logger.info(`   Searching for skill "${slug}"...`);
+      const skill = await findSkill(client, slug);
+      logger.info(`   \u2713 Found: ${skill.name} (${skill.id})`);
+      apiResponse = skill;
+      resource = skillResponseToResource(skill);
+      break;
+    }
+  }
+  const relativeResourcePath = writeResourceFiles(rootDir, resourceType, resource, apiResponse);
+  addImportToCodemieYaml(rootDir, appConfig.codemieConfig, resourceType, relativeResourcePath);
+  updateState(stateManager, resourceType, resource, apiResponse);
+  logger.info(`
+\u2705 Successfully imported ${resourceType} "${resource.name}"
+`);
+}
+init_logger();
+
+// src/lib/terminalPromptHelpers.ts
+init_commandSpinner();
+async function promptUser(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const displayQuestion = `${question}: `;
+  const answer = await pauseSpinnerWhile(
+    () => new Promise((resolve3) => {
+      rl.question(displayQuestion, resolve3);
+    })
+  );
+  rl.close();
+  const trimmedAnswer = answer.trim();
+  return trimmedAnswer || defaultValue || "";
+}
+
+// src/destroy.ts
 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");
@@ -3153,7 +4263,7 @@ async function destroyResources(options) {
     logger.info(`Project: ${config.project.name}
 `);
     const managed = stateManager.getAllManagedResources();
-    const total = managed.assistants.length + managed.datasources.length + managed.workflows.length;
+    const total = managed.assistants.length + managed.datasources.length + managed.workflows.length + managed.skills.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");
@@ -3179,21 +4289,19 @@ async function destroyResources(options) {
         logger.info(`     \u2022 ${name}`);
       }
     }
+    if (managed.skills.length > 0) {
+      logger.info(`  \u{1F3AF} Skills: ${managed.skills.length}`);
+      for (const name of managed.skills) {
+        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();
+      const answer = await promptUser('Type "destroy" to confirm deletion');
       if (answer.trim().toLowerCase() !== "destroy") {
         logger.info("\n\u274C Destruction cancelled\n");
         return;
@@ -3203,7 +4311,7 @@ async function destroyResources(options) {
     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;
+    const totalDeleted = result.deleted.assistants.length + result.deleted.datasources.length + result.deleted.workflows.length + result.deleted.skills.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}`);
@@ -3227,4 +4335,4 @@ async function destroyResources(options) {
   }
 }
 
-export { CleanupManager, CodemieConfigLoader, LogLevel, StateManager, backupResources, createClient, deployAssistants, deployDatasources, deployResources, deployWorkflows, destroyResources, logger, previewChanges, validateConfig };
+export { CleanupManager, CodemieConfigLoader, LogLevel, StateManager, backupResources, createClient, deployAssistants, deployDatasources, deployResources, deploySkills, deployWorkflows, destroyResources, importResource, logger, previewChanges, validateConfig };