@codemieai/cdk 0.1.440 → 0.1.445

package/dist/cli/index.js

@@ -1,98 +1,26 @@
 #!/usr/bin/env node
+import * as fs6 from 'fs';
 import * as path6 from 'path';
 import path6__default from 'path';
+import ora from 'ora';
+import * as crypto2 from 'crypto';
+import { DataSourceType, CodeMieClient } from 'codemie-sdk';
+import * as yaml5 from 'yaml';
 import { program } from '@commander-js/extra-typings';
-import * as fs2 from 'fs';
 import { z } from 'zod';
 import 'dotenv/config';
-import * as crypto from 'crypto';
-import * as yaml3 from 'yaml';
-import { CodeMieClient, DataSourceType } from 'codemie-sdk';
 import pLimit from 'p-limit';
 import * as readline from 'readline';
 
-// package.json
-var package_default = {
-  version: "0.1.440"};
-var appConfigSchema = z.object({
-  rootDir: z.string(),
-  codemieConfig: z.string(),
-  codemieState: z.string(),
-  backupsDirectory: z.string()
-});
-var externalConfigSchema = appConfigSchema.partial();
-
-// src/appConfig/defaultConfig.ts
-var defaultConfig = {
-  rootDir: "./",
-  codemieConfig: "codemie.yaml",
-  codemieState: ".codemie/state.json",
-  backupsDirectory: "backups"
-};
-
-// src/appConfig/configLoader.ts
-function loadAppConfig(userConfigPath) {
-  if (!userConfigPath) {
-    return defaultConfig;
-  }
-  const userConfig = loadUserConfig(userConfigPath);
-  const sanitizedUserConfig = removeEmptyFields(userConfig);
-  const merged = { ...defaultConfig, ...sanitizedUserConfig };
-  return appConfigSchema.parse(merged);
-}
-function loadUserConfig(configPath) {
-  const resolvedPath = path6.resolve(process.cwd(), configPath);
-  if (!fs2.existsSync(resolvedPath)) {
-    throw new Error(`Config file not found: ${resolvedPath}`);
-  }
-  let raw;
-  try {
-    raw = fs2.readFileSync(resolvedPath, "utf8");
-  } catch (error) {
-    throw new Error(`Failed to read config file: ${resolvedPath}`, { cause: error });
-  }
-  let json;
-  try {
-    json = JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`Malformed JSON in config file: ${resolvedPath}`, { cause: error });
-  }
-  try {
-    return externalConfigSchema.parse(json);
-  } catch (error) {
-    throw new Error(`Invalid config structure: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function removeEmptyFields(userConfig) {
-  return Object.fromEntries(
-    Object.entries(userConfig).filter(([_, value]) => {
-      if (value === null || value === void 0) {
-        return false;
-      }
-      return value.trim() !== "";
-    })
-  );
-}
-
-// src/lib/constants.ts
-var PAGINATION = {
-  DEFAULT_PAGE_SIZE: 100};
-var TIMEOUTS_MS = {
-  ASSISTANT_FETCH: 3e4,
-  DATASOURCE_FETCH: 3e4,
-  WORKFLOW_FETCH: 3e4,
-  INTEGRATION_FETCH: 3e4
-};
-var RATE_LIMITING = {
-  MAX_CONCURRENT_REQUESTS: 5,
-  RETRY_ATTEMPTS: 3,
-  RETRY_DELAY_MS: 1e3
+var __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 BACKUP = {
-  TEMP_DIR_PREFIX: ".temp-",
-  TRANSACTION_SAVE_TIMEOUT_MS: 5e3
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-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);
@@ -104,14 +32,14 @@ function sanitizeFileName(name, maxLength = 255) {
 function validateBackupDirectory(backupDir, minSpaceGB = 1) {
   try {
     const parentDir = path6.dirname(backupDir);
-    if (!fs2.existsSync(parentDir)) {
-      fs2.mkdirSync(parentDir, { recursive: true });
+    if (!fs6.existsSync(parentDir)) {
+      fs6.mkdirSync(parentDir, { recursive: true });
     }
     const testFile = path6.join(parentDir, ".write-test");
-    fs2.writeFileSync(testFile, "test");
-    fs2.unlinkSync(testFile);
+    fs6.writeFileSync(testFile, "test");
+    fs6.unlinkSync(testFile);
     try {
-      const stats = fs2.statfsSync(parentDir);
+      const stats = fs6.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`);
@@ -127,7 +55,7 @@ function validateBackupDirectory(backupDir, minSpaceGB = 1) {
 }
 function moveAtomically(tempPath, finalPath) {
   try {
-    fs2.renameSync(tempPath, finalPath);
+    fs6.renameSync(tempPath, finalPath);
   } catch (error) {
     const err = error;
     if (err.code === "EEXIST") {
@@ -137,287 +65,247 @@ function moveAtomically(tempPath, finalPath) {
   }
 }
 function cleanupDirectory(dirPath) {
-  if (fs2.existsSync(dirPath)) {
-    fs2.rmSync(dirPath, { recursive: true, force: true });
+  if (fs6.existsSync(dirPath)) {
+    fs6.rmSync(dirPath, { recursive: true, force: true });
   }
 }
 function ensureDirectoryExists(filePath) {
   const dir = path6.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
 }
-
-// src/lib/logger.ts
-var Logger = class _Logger {
-  static instance;
-  level = 1 /* INFO */;
-  constructor() {
+var BYTES_IN_GB;
+var init_fileUtils = __esm({
+  "src/lib/fileUtils.ts"() {
+    BYTES_IN_GB = 1024 ** 3;
   }
-  static getInstance() {
-    if (!_Logger.instance) {
-      _Logger.instance = new _Logger();
-    }
-    return _Logger.instance;
+});
+function formatDuration(durationMs) {
+  if (durationMs < 1e3) {
+    return `${durationMs}ms`;
   }
-  setLevel(level) {
-    this.level = level;
+  const seconds = durationMs / 1e3;
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
   }
-  debug(message, ...args) {
-    if (this.level <= 0 /* DEBUG */) {
-      console.debug(message, ...args);
-    }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.round(seconds % 60);
+  return `${minutes}m ${remainingSeconds}s`;
+}
+function normalizeExitCode(code) {
+  if (typeof code === "number" && Number.isFinite(code)) {
+    return code;
   }
-  info(message, ...args) {
-    if (this.level <= 1 /* INFO */) {
-      console.log(message, ...args);
+  if (typeof code === "string") {
+    const parsed = Number(code);
+    if (Number.isFinite(parsed)) {
+      return parsed;
     }
   }
-  warn(message, ...args) {
-    if (this.level <= 2 /* WARN */) {
-      console.warn(message, ...args);
-    }
+  return 0;
+}
+function startSpinner(text) {
+  spinnerManager.start(text);
+}
+function succeedSpinner(text) {
+  spinnerManager.succeed(text);
+}
+function failSpinner(text) {
+  spinnerManager.fail(text);
+}
+function pauseSpinner(operation) {
+  return spinnerManager.pause(operation);
+}
+function pauseSpinnerWhile(operation) {
+  return spinnerManager.pauseWhile(operation);
+}
+async function runCommandWithSpinner(commandLabel, action) {
+  const originalExit = process.exit;
+  const previousExitCode = process.exitCode;
+  const startTime = Date.now();
+  let interceptedExitCode;
+  startSpinner(`${commandLabel}...`);
+  process.exit = ((code) => {
+    interceptedExitCode = normalizeExitCode(code);
+    process.exitCode = interceptedExitCode;
+    return void 0;
+  });
+  try {
+    await action();
+  } catch (error) {
+    const duration2 = formatDuration(Date.now() - startTime);
+    failSpinner(`${commandLabel} failed in ${duration2}`);
+    if ((interceptedExitCode ?? process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(errorMessage);
+    }
+    return;
+  } finally {
+    process.exit = originalExit;
   }
-  error(message, ...args) {
-    if (this.level <= 3 /* ERROR */) {
-      console.error(message, ...args);
-    }
+  const exitCode = interceptedExitCode ?? process.exitCode ?? previousExitCode ?? 0;
+  const duration = formatDuration(Date.now() - startTime);
+  if (exitCode === 0) {
+    succeedSpinner(`${commandLabel} completed in ${duration}`);
+  } else {
+    failSpinner(`${commandLabel} failed in ${duration}`);
   }
-};
-var logger = Logger.getInstance();
-
-// src/lib/backupTransaction.ts
-function busyWaitDelay(ms) {
 }
-var BackupTransaction = class {
-  data;
-  transactionPath;
-  isDirty = false;
-  saveTimer;
-  constructor(backupDir, transactionId) {
-    this.transactionPath = path6.join(backupDir, "transaction.json");
-    try {
-      const content = fs2.readFileSync(this.transactionPath, "utf8");
-      this.data = JSON.parse(content);
-      logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id}`);
-    } catch (error) {
-      const err = error;
-      if (err.code === "ENOENT") {
-        this.data = this.createNewTransaction(backupDir, transactionId);
-      } else {
-        throw error;
+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;
       }
-    }
-  }
-  createNewTransaction(backupDir, transactionId) {
-    const newData = {
-      id: transactionId || this.generateTransactionId(),
-      status: "in-progress",
-      startTime: (/* @__PURE__ */ new Date()).toISOString(),
-      backupDir,
-      resources: {
-        assistants: { total: 0, completed: [], failed: [] },
-        datasources: { total: 0, completed: [], failed: [] },
-        workflows: { total: 0, completed: [], failed: [] },
-        integrations: { total: 0, completed: [], failed: [] }
+      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();
+          }
+        }
       }
     };
-    ensureDirectoryExists(this.transactionPath);
-    this.writeTransactionExclusively(newData);
-    return newData;
+    spinnerManager = new CommandSpinnerManager();
   }
-  writeTransactionExclusively(data) {
-    try {
-      const fd = fs2.openSync(this.transactionPath, "wx");
-      fs2.writeSync(fd, JSON.stringify(data, null, 2));
-      fs2.closeSync(fd);
-    } catch (writeError) {
-      const writeErr = writeError;
-      if (writeErr.code === "EEXIST") {
-        this.readWithRetry();
-      } else {
-        throw writeError;
+});
+
+// src/lib/logger.ts
+var Logger, logger;
+var init_logger = __esm({
+  "src/lib/logger.ts"() {
+    init_commandSpinner();
+    Logger = class _Logger {
+      static instance;
+      level = 1 /* INFO */;
+      constructor() {
       }
-    }
-  }
-  readWithRetry() {
-    let retries = 3;
-    let lastReadError;
-    while (retries > 0) {
-      try {
-        const delayMs = 100 * (4 - retries);
-        if (delayMs > 0) {
-          busyWaitDelay(delayMs);
+      static getInstance() {
+        if (!_Logger.instance) {
+          _Logger.instance = new _Logger();
         }
-        const content = fs2.readFileSync(this.transactionPath, "utf8");
-        this.data = JSON.parse(content);
-        logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id} (created by concurrent process)`);
-        break;
-      } catch (readError) {
-        lastReadError = readError instanceof Error ? readError : new Error(String(readError));
-        retries--;
-        if (retries === 0) {
-          throw new Error(
-            `Failed to read transaction file after retries: ${lastReadError.message}. File may be corrupted. Delete ${this.transactionPath} and retry.`
-          );
+        return _Logger.instance;
+      }
+      setLevel(level) {
+        this.level = level;
+      }
+      debug(message, ...args) {
+        if (this.level <= 0 /* DEBUG */) {
+          pauseSpinner(() => {
+            console.debug(message, ...args);
+          });
         }
       }
-    }
-  }
-  generateTransactionId() {
-    return crypto.randomBytes(8).toString("hex");
-  }
-  /**
-   * Save transaction state to disk (checkpoint) with timeout protection
-   */
-  async save() {
-    ensureDirectoryExists(this.transactionPath);
-    const savePromise = fs2.promises.writeFile(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
-    let timeoutId;
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(
-        () => reject(new Error(`Transaction save timeout after ${BACKUP.TRANSACTION_SAVE_TIMEOUT_MS}ms`)),
-        BACKUP.TRANSACTION_SAVE_TIMEOUT_MS
-      );
-      timeoutId.unref();
-    });
-    try {
-      await Promise.race([savePromise, timeoutPromise]);
-      this.isDirty = false;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      throw new Error(`Failed to save transaction file: ${err.message}`);
-    } finally {
-      if (timeoutId !== void 0) {
-        clearTimeout(timeoutId);
+      info(message, ...args) {
+        if (this.level <= 1 /* INFO */) {
+          pauseSpinner(() => {
+            console.log(message, ...args);
+          });
+        }
       }
-    }
-  }
-  /**
-   * Internal synchronous save for batching
-   */
-  saveSyncInternal() {
-    ensureDirectoryExists(this.transactionPath);
-    fs2.writeFileSync(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
-    this.isDirty = false;
-  }
-  /**
-   * Schedule batched save (debounced to avoid excessive disk writes)
-   */
-  scheduleSave() {
-    if (this.saveTimer) {
-      return;
-    }
-    this.saveTimer = setTimeout(() => {
-      if (this.isDirty) {
-        this.saveSyncInternal();
+      warn(message, ...args) {
+        if (this.level <= 2 /* WARN */) {
+          pauseSpinner(() => {
+            console.warn(message, ...args);
+          });
+        }
       }
-      this.saveTimer = void 0;
-    }, 1e3);
-    this.saveTimer.unref();
+      error(message, ...args) {
+        if (this.level <= 3 /* ERROR */) {
+          pauseSpinner(() => {
+            console.error(message, ...args);
+          });
+        }
+      }
+    };
+    logger = Logger.getInstance();
   }
-  /**
-   * Internal method to finalize transaction with a specific status
-   */
-  end(status) {
-    this.data.status = status;
-    this.data.endTime = (/* @__PURE__ */ new Date()).toISOString();
-    this.flush();
-  }
-  /**
-   * Force immediate save (flush pending changes)
-   */
-  flush() {
-    if (this.saveTimer) {
-      clearTimeout(this.saveTimer);
-      this.saveTimer = void 0;
-    }
-    if (this.isDirty) {
-      this.saveSyncInternal();
-    }
-  }
-  /**
-   * Set total count for a resource type
-   */
-  setTotal(resourceType, total) {
-    this.data.resources[resourceType].total = total;
-    this.isDirty = true;
-    this.scheduleSave();
-  }
-  /**
-   * Mark resource as completed
-   */
-  markCompleted(resourceType, resourceId) {
-    if (!this.data.resources[resourceType].completed.includes(resourceId)) {
-      this.data.resources[resourceType].completed.push(resourceId);
-      this.isDirty = true;
-      this.scheduleSave();
-    }
-  }
-  /**
-   * Mark resource as failed
-   */
-  markFailed(resourceType, resourceId, error) {
-    const failedEntry = { id: resourceId, error };
-    const failedList = this.data.resources[resourceType].failed;
-    if (!failedList.some((f) => f.id === resourceId)) {
-      failedList.push(failedEntry);
-      this.isDirty = true;
-      this.scheduleSave();
-    }
-  }
-  /**
-   * Check if resource was already backed up
-   */
-  isCompleted(resourceType, resourceId) {
-    return this.data.resources[resourceType].completed.includes(resourceId);
-  }
-  /**
-   * Mark transaction as completed
-   */
-  complete() {
-    this.end("completed");
-  }
-  /**
-   * Mark transaction as failed
-   */
-  fail() {
-    this.end("failed");
-  }
-  /**
-   * Get transaction data (returns deep copy to prevent external modifications)
-   */
-  getData() {
-    return structuredClone(this.data);
-  }
-  /**
-   * Get summary of backup progress
-   */
-  getSummary() {
-    const { resources } = this.data;
-    const lines = [];
-    for (const [type, data] of Object.entries(resources)) {
-      const completed = data.completed.length;
-      const failed = data.failed.length;
-      const total = data.total;
-      const percent = total > 0 ? Math.round(completed / total * 100) : 0;
-      lines.push(`  ${type}: ${completed}/${total} (${percent}%) ${failed > 0 ? `[${failed} failed]` : ""}`);
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Clean up transaction file after successful completion
-   */
-  cleanup() {
-    if (fs2.existsSync(this.transactionPath)) {
-      fs2.unlinkSync(this.transactionPath);
-    }
-  }
-};
-var DEFAULT_LLM_MODEL = "gpt-4";
-function normalizeIntegrationSettings(settings) {
-  if (!settings || typeof settings !== "object") {
-    return settings;
+});
+function normalizeIntegrationSettings(settings) {
+  if (!settings || typeof settings !== "object") {
+    return settings;
   }
   if ("$ref" in settings && typeof settings.$ref === "string") {
     return { $ref: settings.$ref };
@@ -466,7 +354,7 @@ function calculateChecksum(content) {
   if (content.length === 0) {
     logger.warn("\u26A0\uFE0F  Calculating checksum of empty string");
   }
-  return crypto.createHash("sha256").update(content, "utf8").digest("hex");
+  return crypto2.createHash("sha256").update(content, "utf8").digest("hex");
 }
 function normalizeAssistantConfig(assistant, buildConfig = null) {
   return {
@@ -483,6 +371,7 @@ function normalizeAssistantConfig(assistant, buildConfig = null) {
     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
   };
@@ -491,13 +380,18 @@ 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);
 }
-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();
@@ -520,6 +414,19 @@ 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) {
@@ -531,8 +438,34 @@ function hasSettingId(obj) {
 function isResolvedIntegration(obj) {
   return typeof obj === "object" && obj !== null && "id" in obj && typeof obj.id === "string";
 }
-
-// src/lib/converters.ts
+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;
@@ -587,14 +520,15 @@ function convertMcpServers(servers) {
   return validServers;
 }
 function assistantResponseToResource(assistant) {
+  const safeName = assistant.name || assistant.id || "assistant";
   const slug = assistant.slug || "";
-  const promptFileName = slug || assistant.name.toLowerCase().replaceAll(/\s+/g, "-");
+  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,
+    name: assistant.name || safeName,
     description: assistant.description || "",
     prompt: `system_prompts/${promptFileName}.prompt.md`,
     model: assistant.llm_model_type || DEFAULT_LLM_MODEL,
@@ -615,6 +549,7 @@ function assistantResponseToResource(assistant) {
 }
 function convertCodeDatasource(datasource, base) {
   const desc = datasource.description || "";
+  const indexType = normalizeCodeIndexType(datasource);
   if (datasource.code) {
     return {
       ...base,
@@ -622,7 +557,7 @@ function convertCodeDatasource(datasource, base) {
       description: desc,
       link: datasource.code.link,
       branch: datasource.code.branch,
-      index_type: datasource.code.indexType,
+      ...indexType && { index_type: indexType },
       summarization_model: datasource.code.summarizationModel,
       files_filter: datasource.code.filesFilter
     };
@@ -631,12 +566,17 @@ function convertCodeDatasource(datasource, base) {
     ...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(["knowledge_base_file", "llm_routing_google"]);
+  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)`);
   }
@@ -647,7 +587,7 @@ function datasourceResponseToResource(datasource, integrationAlias) {
     setting_id: settingId || void 0,
     shared_with_project: datasource.shared_with_project
   };
-  if (datasource.type === DataSourceType.CODE) {
+  if (isCodeFamilyDatasource) {
     return convertCodeDatasource(datasource, base);
   }
   if (datasource.type === DataSourceType.CONFLUENCE && datasource.confluence) {
@@ -681,6 +621,13 @@ function datasourceResponseToResource(datasource, integrationAlias) {
       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,
@@ -688,15 +635,26 @@ function datasourceResponseToResource(datasource, integrationAlias) {
   };
 }
 function workflowResponseToResource(workflow) {
+  const safeName = workflow.name || workflow.id || "workflow";
   return {
-    name: workflow.name,
+    name: workflow.name || safeName,
     description: workflow.description || "",
-    definition: `workflows/${workflow.name.toLowerCase().replaceAll(/\s+/g, "-")}.yaml`,
+    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;
 }
@@ -761,6 +719,7 @@ function assistantResourceToCreateParams(assistant, projectName, promptContent)
     model,
     sub_assistants: _subAssistants,
     datasource_names: _datasourceNames,
+    skills: _skills,
     toolkits,
     mcp_servers: mcpServers,
     ...sdkFields
@@ -781,8 +740,28 @@ function assistantResourceToCreateParams(assistant, projectName, promptContent)
     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"]);
+  }
+});
 
 // 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);
@@ -849,94 +828,439 @@ function transformMcpServer(mcp, integrationIdToAlias) {
       );
     }
   }
-  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 = yaml3.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 = path6.join(backupDir, "workflows", fileName);
-        ensureDirectoryExists(filePath);
-        finalYamlContent = yaml3.stringify(transformedYaml);
-        fs2.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)}`
-      );
+  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 = yaml5.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 = path6.join(backupDir, "workflows", fileName);
+        ensureDirectoryExists(filePath);
+        finalYamlContent = yaml5.stringify(transformedYaml);
+        fs6.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();
+  }
+});
+
+// package.json
+var package_default = {
+  version: "0.1.445"};
+var appConfigSchema = z.object({
+  rootDir: z.string(),
+  codemieConfig: z.string(),
+  codemieState: z.string(),
+  backupsDirectory: z.string()
+});
+var externalConfigSchema = appConfigSchema.partial();
+
+// src/appConfig/defaultConfig.ts
+var defaultConfig = {
+  rootDir: "./",
+  codemieConfig: "codemie.yaml",
+  codemieState: ".codemie/state.json",
+  backupsDirectory: "backups"
+};
+
+// src/appConfig/configLoader.ts
+function loadAppConfig(userConfigPath) {
+  if (!userConfigPath) {
+    return defaultConfig;
+  }
+  const userConfig = loadUserConfig(userConfigPath);
+  const sanitizedUserConfig = removeEmptyFields(userConfig);
+  const merged = { ...defaultConfig, ...sanitizedUserConfig };
+  return appConfigSchema.parse(merged);
+}
+function loadUserConfig(configPath) {
+  const resolvedPath = path6.resolve(process.cwd(), configPath);
+  if (!fs6.existsSync(resolvedPath)) {
+    throw new Error(`Config file not found: ${resolvedPath}`);
+  }
+  let raw;
+  try {
+    raw = fs6.readFileSync(resolvedPath, "utf8");
+  } catch (error) {
+    throw new Error(`Failed to read config file: ${resolvedPath}`, { cause: error });
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Malformed JSON in config file: ${resolvedPath}`, { cause: error });
+  }
+  try {
+    return externalConfigSchema.parse(json);
+  } catch (error) {
+    throw new Error(`Invalid config structure: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function removeEmptyFields(userConfig) {
+  return Object.fromEntries(
+    Object.entries(userConfig).filter(([_, value]) => {
+      if (value === null || value === void 0) {
+        return false;
+      }
+      return value.trim() !== "";
+    })
+  );
+}
+
+// src/lib/constants.ts
+var PAGINATION = {
+  DEFAULT_PAGE_SIZE: 100};
+var TIMEOUTS_MS = {
+  ASSISTANT_FETCH: 3e4,
+  DATASOURCE_FETCH: 3e4,
+  WORKFLOW_FETCH: 3e4,
+  INTEGRATION_FETCH: 3e4,
+  SKILL_FETCH: 3e4
+};
+var RATE_LIMITING = {
+  MAX_CONCURRENT_REQUESTS: 5,
+  RETRY_ATTEMPTS: 3,
+  RETRY_DELAY_MS: 1e3
+};
+var BACKUP = {
+  TEMP_DIR_PREFIX: ".temp-",
+  TRANSACTION_SAVE_TIMEOUT_MS: 5e3
+};
+
+// src/lib/backupTransaction.ts
+init_fileUtils();
+init_logger();
+function busyWaitDelay(ms) {
+}
+var BackupTransaction = class {
+  data;
+  transactionPath;
+  isDirty = false;
+  saveTimer;
+  constructor(backupDir, transactionId) {
+    this.transactionPath = path6.join(backupDir, "transaction.json");
+    try {
+      const content = fs6.readFileSync(this.transactionPath, "utf8");
+      this.data = JSON.parse(content);
+      logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id}`);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        this.data = this.createNewTransaction(backupDir, transactionId);
+      } else {
+        throw error;
+      }
+    }
+  }
+  createNewTransaction(backupDir, transactionId) {
+    const newData = {
+      id: transactionId || this.generateTransactionId(),
+      status: "in-progress",
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      backupDir,
+      resources: {
+        assistants: { total: 0, completed: [], failed: [] },
+        datasources: { total: 0, completed: [], failed: [] },
+        workflows: { total: 0, completed: [], failed: [] },
+        integrations: { total: 0, completed: [], failed: [] },
+        skills: { total: 0, completed: [], failed: [] }
+      }
+    };
+    ensureDirectoryExists(this.transactionPath);
+    this.writeTransactionExclusively(newData);
+    return newData;
+  }
+  writeTransactionExclusively(data) {
+    try {
+      const fd = fs6.openSync(this.transactionPath, "wx");
+      fs6.writeSync(fd, JSON.stringify(data, null, 2));
+      fs6.closeSync(fd);
+    } catch (writeError) {
+      const writeErr = writeError;
+      if (writeErr.code === "EEXIST") {
+        this.readWithRetry();
+      } else {
+        throw writeError;
+      }
+    }
+  }
+  readWithRetry() {
+    let retries = 3;
+    let lastReadError;
+    while (retries > 0) {
+      try {
+        const delayMs = 100 * (4 - retries);
+        if (delayMs > 0) {
+          busyWaitDelay(delayMs);
+        }
+        const content = fs6.readFileSync(this.transactionPath, "utf8");
+        this.data = JSON.parse(content);
+        logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id} (created by concurrent process)`);
+        break;
+      } catch (readError) {
+        lastReadError = readError instanceof Error ? readError : new Error(String(readError));
+        retries--;
+        if (retries === 0) {
+          throw new Error(
+            `Failed to read transaction file after retries: ${lastReadError.message}. File may be corrupted. Delete ${this.transactionPath} and retry.`
+          );
+        }
+      }
+    }
+  }
+  generateTransactionId() {
+    return crypto2.randomBytes(8).toString("hex");
+  }
+  /**
+   * Save transaction state to disk (checkpoint) with timeout protection
+   */
+  async save() {
+    ensureDirectoryExists(this.transactionPath);
+    const savePromise = fs6.promises.writeFile(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(
+        () => reject(new Error(`Transaction save timeout after ${BACKUP.TRANSACTION_SAVE_TIMEOUT_MS}ms`)),
+        BACKUP.TRANSACTION_SAVE_TIMEOUT_MS
+      );
+      timeoutId.unref();
+    });
+    try {
+      await Promise.race([savePromise, timeoutPromise]);
+      this.isDirty = false;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      throw new Error(`Failed to save transaction file: ${err.message}`);
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  /**
+   * Internal synchronous save for batching
+   */
+  saveSyncInternal() {
+    ensureDirectoryExists(this.transactionPath);
+    fs6.writeFileSync(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
+    this.isDirty = false;
+  }
+  /**
+   * Schedule batched save (debounced to avoid excessive disk writes)
+   */
+  scheduleSave() {
+    if (this.saveTimer) {
+      return;
+    }
+    this.saveTimer = setTimeout(() => {
+      if (this.isDirty) {
+        this.saveSyncInternal();
+      }
+      this.saveTimer = void 0;
+    }, 1e3);
+    this.saveTimer.unref();
+  }
+  /**
+   * Internal method to finalize transaction with a specific status
+   */
+  end(status) {
+    this.data.status = status;
+    this.data.endTime = (/* @__PURE__ */ new Date()).toISOString();
+    this.flush();
+  }
+  /**
+   * Force immediate save (flush pending changes)
+   */
+  flush() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = void 0;
+    }
+    if (this.isDirty) {
+      this.saveSyncInternal();
+    }
+  }
+  /**
+   * Set total count for a resource type
+   */
+  setTotal(resourceType, total) {
+    this.data.resources[resourceType].total = total;
+    this.isDirty = true;
+    this.scheduleSave();
+  }
+  /**
+   * Mark resource as completed
+   */
+  markCompleted(resourceType, resourceId) {
+    if (!this.data.resources[resourceType].completed.includes(resourceId)) {
+      this.data.resources[resourceType].completed.push(resourceId);
+      this.isDirty = true;
+      this.scheduleSave();
+    }
+  }
+  /**
+   * Mark resource as failed
+   */
+  markFailed(resourceType, resourceId, error) {
+    const failedEntry = { id: resourceId, error };
+    const failedList = this.data.resources[resourceType].failed;
+    if (!failedList.some((f) => f.id === resourceId)) {
+      failedList.push(failedEntry);
+      this.isDirty = true;
+      this.scheduleSave();
+    }
+  }
+  /**
+   * Check if resource was already backed up
+   */
+  isCompleted(resourceType, resourceId) {
+    return this.data.resources[resourceType].completed.includes(resourceId);
+  }
+  /**
+   * Mark transaction as completed
+   */
+  complete() {
+    this.end("completed");
+  }
+  /**
+   * Mark transaction as failed
+   */
+  fail() {
+    this.end("failed");
+  }
+  /**
+   * Get transaction data (returns deep copy to prevent external modifications)
+   */
+  getData() {
+    return structuredClone(this.data);
+  }
+  /**
+   * Get summary of backup progress
+   */
+  getSummary() {
+    const { resources } = this.data;
+    const lines = [];
+    for (const [type, data] of Object.entries(resources)) {
+      const completed = data.completed.length;
+      const failed = data.failed.length;
+      const total = data.total;
+      const percent = total > 0 ? Math.round(completed / total * 100) : 0;
+      lines.push(`  ${type}: ${completed}/${total} (${percent}%) ${failed > 0 ? `[${failed} failed]` : ""}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Clean up transaction file after successful completion
+   */
+  cleanup() {
+    if (fs6.existsSync(this.transactionPath)) {
+      fs6.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;
@@ -992,17 +1316,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 yaml3.stringify(config);
+  return yaml5.stringify(config);
 }
 function saveIntegrationOpenApiSpecs(backupData, backupDir) {
   const specsDir = path6.join(backupDir, "openapi_specs");
@@ -1018,8 +1345,8 @@ function saveIntegrationOpenApiSpecs(backupData, backupDir) {
     if (specEntry && typeof specEntry.value === "string" && specEntry.value) {
       const alias = integration.alias || integration.id;
       const fileName = String(alias).toLowerCase().replaceAll(/[^a-z0-9]+/g, "-");
-      if (!fs2.existsSync(specsDir)) {
-        fs2.mkdirSync(specsDir, { recursive: true });
+      if (!fs6.existsSync(specsDir)) {
+        fs6.mkdirSync(specsDir, { recursive: true });
       }
       const specContent = specEntry.value;
       let fileExtension = ".yaml";
@@ -1033,7 +1360,7 @@ function saveIntegrationOpenApiSpecs(backupData, backupDir) {
       }
       const specFileName = `${fileName}${fileExtension}`;
       const specPath = path6.join(specsDir, specFileName);
-      fs2.writeFileSync(specPath, contentToSave, "utf8");
+      fs6.writeFileSync(specPath, contentToSave, "utf8");
       integrationSpecPaths.set(integration.id, `openapi_specs/${specFileName}`);
       specsCount++;
     }
@@ -1048,13 +1375,13 @@ function saveBackupFiles(backupData, backupDir, projectName) {
   const integrationSpecPaths = saveIntegrationOpenApiSpecs(backupData, backupDir);
   const codemieYamlPath = path6.join(backupDir, "codemie.yaml");
   const codemieYaml = generateCodemieYaml(backupData, projectName, backupDir, integrationSpecPaths);
-  fs2.writeFileSync(codemieYamlPath, codemieYaml, "utf8");
+  fs6.writeFileSync(codemieYamlPath, codemieYaml, "utf8");
   logger.info(`   \u2713 Saved config file: codemie.yaml`);
   const backupJsonPath = path6.join(backupDir, "backup.json");
-  fs2.writeFileSync(backupJsonPath, JSON.stringify(backupData, null, 2), "utf8");
+  fs6.writeFileSync(backupJsonPath, JSON.stringify(backupData, null, 2), "utf8");
   logger.info(`   \u2713 Saved full backup: backup.json`);
   const statePath = path6.join(backupDir, "state.json");
-  fs2.writeFileSync(statePath, JSON.stringify(backupData.state, null, 2), "utf8");
+  fs6.writeFileSync(statePath, JSON.stringify(backupData.state, null, 2), "utf8");
   logger.info(`   \u2713 Saved state file: state.json`);
 }
 async function createClient(config) {
@@ -1068,7 +1395,14 @@ 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;
 }
 var CodemieConfigLoader = class {
@@ -1082,11 +1416,11 @@ var CodemieConfigLoader = class {
   loadConfig() {
     const { rootDir, codemieConfig } = this.appConfig;
     const configPath = path6.join(rootDir, codemieConfig);
-    if (!fs2.existsSync(configPath)) {
+    if (!fs6.existsSync(configPath)) {
       throw new Error(`Configuration file not found: ${configPath}`);
     }
-    const content = fs2.readFileSync(configPath, "utf8");
-    const config = yaml3.parse(content);
+    const content = fs6.readFileSync(configPath, "utf8");
+    const config = yaml5.parse(content);
     this.resolveImports(config, rootDir);
     this.substituteEnvVars(config);
     this.applyDatasourceDefaults(config);
@@ -1100,10 +1434,21 @@ var CodemieConfigLoader = class {
   loadPrompt(promptPath) {
     const { rootDir } = this.appConfig;
     const fullPath = path6.join(rootDir, promptPath);
-    if (!fs2.existsSync(fullPath)) {
+    if (!fs6.existsSync(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
-    return fs2.readFileSync(fullPath, "utf8");
+    return fs6.readFileSync(fullPath, "utf8");
+  }
+  /**
+   * Load skill content file (.skill.md)
+   */
+  loadSkillContent(contentPath) {
+    const { rootDir } = this.appConfig;
+    const fullPath = path6.join(rootDir, contentPath);
+    if (!fs6.existsSync(fullPath)) {
+      throw new Error(`Skill content file not found: ${fullPath}`);
+    }
+    return fs6.readFileSync(fullPath, "utf8");
   }
   /**
    * Load assistant configuration file
@@ -1111,11 +1456,11 @@ var CodemieConfigLoader = class {
   loadAssistantConfig(configPath) {
     const { rootDir } = this.appConfig;
     const fullPath = path6.join(rootDir, configPath);
-    if (!fs2.existsSync(fullPath)) {
+    if (!fs6.existsSync(fullPath)) {
       throw new Error(`Config file not found: ${fullPath}`);
     }
-    const content = fs2.readFileSync(fullPath, "utf8");
-    return yaml3.parse(content);
+    const content = fs6.readFileSync(fullPath, "utf8");
+    return yaml5.parse(content);
   }
   /**
    * Validate that all referenced files exist
@@ -1126,12 +1471,12 @@ var CodemieConfigLoader = class {
     if (config.resources.assistants) {
       for (const assistant of config.resources.assistants) {
         const promptPath = path6.join(rootDir, assistant.prompt);
-        if (!fs2.existsSync(promptPath)) {
+        if (!fs6.existsSync(promptPath)) {
           errors.push(`Prompt file not found for ${assistant.name}: ${assistant.prompt}`);
         }
         if (assistant.config) {
           const configPath = path6.join(rootDir, assistant.config);
-          if (!fs2.existsSync(configPath)) {
+          if (!fs6.existsSync(configPath)) {
             errors.push(`Config file not found for ${assistant.name}: ${assistant.config}`);
           }
         }
@@ -1143,6 +1488,17 @@ var CodemieConfigLoader = class {
         }
       }
     }
+    if (config.resources.skills) {
+      for (const skill of config.resources.skills) {
+        const contentPath = path6.join(rootDir, skill.file);
+        if (!fs6.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
@@ -1234,12 +1590,12 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
    * Load YAML file with error handling
    */
   loadYamlFile(filePath) {
-    if (!fs2.existsSync(filePath)) {
+    if (!fs6.existsSync(filePath)) {
       throw new Error(`Import file not found: ${filePath}`);
     }
     try {
-      const content = fs2.readFileSync(filePath, "utf8");
-      const parsed = yaml3.parse(content);
+      const content = fs6.readFileSync(filePath, "utf8");
+      const parsed = yaml5.parse(content);
       if (parsed === null || parsed === void 0) {
         throw new TypeError(`Import file ${filePath} is empty`);
       }
@@ -1259,28 +1615,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, path15 = "") {
+  resolveReferencesRecursive(current, rootConfig, path16 = "") {
     if (!current || typeof current !== "object") {
       return;
     }
     if (Array.isArray(current)) {
-      this.resolveArrayReferences(current, rootConfig, path15);
+      this.resolveArrayReferences(current, rootConfig, path16);
       return;
     }
     if ("$ref" in current && typeof current.$ref === "string") {
-      this.resolveObjectReference(current, rootConfig, path15);
+      this.resolveObjectReference(current, rootConfig, path16);
       return;
     }
-    this.resolveObjectProperties(current, rootConfig, path15);
+    this.resolveObjectProperties(current, rootConfig, path16);
   }
   /**
    * 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, path15) {
+  resolveArrayReferences(arr, rootConfig, path16) {
     const result = arr.flatMap((item, i) => {
-      const contextPath = `${path15}[${i}]`;
+      const contextPath = `${path16}[${i}]`;
       if (!this.isRefObject(item) || item.$ref.startsWith("#")) {
         this.resolveReferencesRecursive(item, rootConfig, contextPath);
         return [item];
@@ -1298,9 +1654,9 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
    * Resolve object reference: { $ref: "path" }
    * Replaces object with resolved data (in-place mutation)
    */
-  resolveObjectReference(current, rootConfig, path15) {
+  resolveObjectReference(current, rootConfig, path16) {
     const refPath = current.$ref;
-    const contextPath = path15 || "root";
+    const contextPath = path16 || "root";
     if (refPath.startsWith("#")) {
       return;
     }
@@ -1310,24 +1666,24 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
       delete current[key];
     }
     Object.assign(current, filteredResolved);
-    this.resolveReferencesRecursive(current, rootConfig, path15);
+    this.resolveReferencesRecursive(current, rootConfig, path16);
   }
   /**
    * Resolve object properties recursively
    * Handles both nested objects and "$ref:path" string references
    */
-  resolveObjectProperties(current, rootConfig, path15) {
+  resolveObjectProperties(current, rootConfig, path16) {
     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 = path15 ? `${path15}.${key}` : key;
+        const contextPath = path16 ? `${path16}.${key}` : key;
         const resolved = this.resolveReference(rootConfig, refPath, contextPath);
         current[key] = resolved;
       } else {
-        this.resolveReferencesRecursive(value, rootConfig, path15 ? `${path15}.${key}` : key);
+        this.resolveReferencesRecursive(value, rootConfig, path16 ? `${path16}.${key}` : key);
       }
     }
   }
@@ -1465,6 +1821,11 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
     }
   }
 };
+
+// src/backup.ts
+init_fileUtils();
+init_logger();
+init_logger();
 function createConcurrentLimiter(maxConcurrent = RATE_LIMITING.MAX_CONCURRENT_REQUESTS) {
   return pLimit(maxConcurrent);
 }
@@ -1484,8 +1845,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((resolve6) => {
-        const timerId = setTimeout(resolve6, delayMs);
-        timerId.unref();
+        setTimeout(resolve6, delayMs);
       });
     }
   }
@@ -1509,6 +1869,7 @@ async function withTimeout(promise, timeoutMs, operation) {
 }
 
 // src/backup.ts
+init_backupTransformers();
 async function* streamResources(fetchPage, resourceType) {
   let page = 0;
   let hasMore = true;
@@ -1546,7 +1907,7 @@ async function saveAssistantToBackup(assistant, client, backupData, backupDir) {
     const fileName = `${full.slug || sanitizeFileName(full.name)}.prompt.md`;
     const filePath = path6.join(backupDir, "system_prompts", fileName);
     ensureDirectoryExists(filePath);
-    fs2.writeFileSync(filePath, full.system_prompt, "utf8");
+    fs6.writeFileSync(filePath, full.system_prompt, "utf8");
   }
 }
 async function backupAssistants(client, backupData, backupDir, transaction) {
@@ -1586,21 +1947,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) {
@@ -1653,7 +2035,7 @@ async function backupWorkflows(client, backupData, backupDir, transaction) {
         const fileName = `${sanitizeFileName(full.name)}.yaml`;
         const filePath = path6.join(backupDir, "workflows", fileName);
         ensureDirectoryExists(filePath);
-        fs2.writeFileSync(filePath, full.yaml_config, "utf8");
+        fs6.writeFileSync(filePath, full.yaml_config, "utf8");
       }
       transaction.markCompleted("workflows", workflow.id);
     } catch (error) {
@@ -1669,9 +2051,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,
@@ -1680,7 +2062,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);
@@ -1702,10 +2087,54 @@ 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 = path6.join(backupDir, "skills", fileName);
+          ensureDirectoryExists(filePath);
+          fs6.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 = path6.join(baseDir, timestamp);
-  while (fs2.existsSync(finalBackupDir)) {
+  while (fs6.existsSync(finalBackupDir)) {
     counter++;
     finalBackupDir = path6.join(baseDir, `${timestamp}-${counter}`);
   }
@@ -1714,7 +2143,7 @@ function getUniqueBackupDir(baseDir, timestamp) {
   return { finalDir: finalBackupDir, tempDir: tempBackupDir };
 }
 function performCleanup(tempBackupDir, transaction) {
-  if (fs2.existsSync(tempBackupDir)) {
+  if (fs6.existsSync(tempBackupDir)) {
     try {
       logger.info(`\u{1F9F9} Rolling back: cleaning up ${tempBackupDir}...`);
       cleanupDirectory(tempBackupDir);
@@ -1753,8 +2182,8 @@ async function backupResources(options) {
     logger.info("\u{1F50C} Connecting to Codemie API...");
     const client = await createClient(config);
     logger.info("\u2713 Connected to Codemie API\n");
-    if (!fs2.existsSync(tempBackupDir)) {
-      fs2.mkdirSync(tempBackupDir, { recursive: true });
+    if (!fs6.existsSync(tempBackupDir)) {
+      fs6.mkdirSync(tempBackupDir, { recursive: true });
     }
     logger.info(`\u{1F4C1} Temporary backup directory: ${tempBackupDir}
 `);
@@ -1769,7 +2198,8 @@ async function backupResources(options) {
         assistants: [],
         datasources: [],
         workflows: [],
-        integrations: []
+        integrations: [],
+        skills: []
       },
       state: {
         version: "1.0",
@@ -1778,21 +2208,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(
@@ -1814,6 +2246,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}
 `);
@@ -1833,12 +2266,15 @@ async function main(options) {
   try {
     await backupResources(options);
     process.exit(0);
-  } catch {
+  } catch (error) {
+    logger.error("\n\u274C Backup failed:");
+    logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 }
 
 // src/lib/paginationUtils.ts
+init_logger();
 async function findResourceByName(listFn, name, resourceType) {
   let page = 0;
   const perPage = 100;
@@ -1871,6 +2307,10 @@ async function findAssistantByName(client, name) {
   const assistant = await findResourceByName((params) => client.assistants.list(params), name, "assistant");
   return assistant?.id || null;
 }
+async function findSkillByName(client, name) {
+  const skill = await findResourceByName((params) => client.skills.list(params), name, "skill");
+  return skill?.id || null;
+}
 
 // src/lib/assistantHelpers.ts
 async function createAssistantAndGetId(client, params, slug) {
@@ -1889,12 +2329,18 @@ async function createAssistantAndGetId(client, params, slug) {
   return assistantId;
 }
 
+// src/deploy.ts
+init_checksumUtils();
+
 // 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
@@ -1935,10 +2381,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))
     };
   }
   /**
@@ -1952,7 +2400,8 @@ var CleanupManager = class {
       deleted: {
         assistants: [],
         datasources: [],
-        workflows: []
+        workflows: [],
+        skills: []
       },
       errors: []
     };
@@ -2031,13 +2480,36 @@ var CleanupManager = class {
         );
       }
     }
+    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;
   }
   /**
    * Get summary of orphaned resources
    */
   getOrphanedSummary(orphaned) {
-    const total = orphaned.assistants.length + orphaned.datasources.length + orphaned.workflows.length;
+    const total = orphaned.assistants.length + orphaned.datasources.length + orphaned.workflows.length + (orphaned.skills?.length ?? 0);
     if (total === 0) {
       return "No orphaned resources found";
     }
@@ -2051,10 +2523,18 @@ var CleanupManager = class {
     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(", ")}`;
   }
 };
 
+// src/deploy.ts
+init_codemieConfigChecksums();
+init_converters();
+init_logger();
+
 // src/lib/resourceExistenceChecker.ts
 async function checkResourceExists(getState, getResource) {
   const existingState = getState();
@@ -2086,6 +2566,16 @@ 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/lib/stateManager.ts
+init_checksumUtils();
+init_codemieConfigChecksums();
 var StateManager = class {
   statePath;
   constructor(appConfig) {
@@ -2096,16 +2586,17 @@ var StateManager = class {
    * Load state file
    */
   loadState() {
-    if (!fs2.existsSync(this.statePath)) {
+    if (!fs6.existsSync(this.statePath)) {
       return this.createEmptyState();
     }
-    const content = fs2.readFileSync(this.statePath, "utf8");
+    const content = fs6.readFileSync(this.statePath, "utf8");
     const state = JSON.parse(content);
     if (!state.resources) {
       state.resources = {
         assistants: {},
         datasources: {},
-        workflows: {}
+        workflows: {},
+        skills: {}
       };
     }
     if (!state.resources.assistants) {
@@ -2117,6 +2608,9 @@ var StateManager = class {
     if (!state.resources.workflows) {
       state.resources.workflows = {};
     }
+    if (!state.resources.skills) {
+      state.resources.skills = {};
+    }
     return state;
   }
   /**
@@ -2124,11 +2618,11 @@ var StateManager = class {
    */
   saveState(state) {
     const dir = path6.dirname(this.statePath);
-    if (!fs2.existsSync(dir)) {
-      fs2.mkdirSync(dir, { recursive: true });
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
     }
     state.lastSync = (/* @__PURE__ */ new Date()).toISOString();
-    fs2.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
+    fs6.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
   }
   /**
    * Create empty state structure
@@ -2141,7 +2635,8 @@ var StateManager = class {
       resources: {
         assistants: {},
         datasources: {},
-        workflows: {}
+        workflows: {},
+        skills: {}
       }
     };
   }
@@ -2236,19 +2731,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) {
@@ -2263,6 +2759,9 @@ var StateManager = class {
       case "workflow": {
         return name in state.resources.workflows;
       }
+      case "skill": {
+        return name in (state.resources.skills || {});
+      }
       default: {
         return false;
       }
@@ -2283,11 +2782,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);
+  }
 };
 
 // src/deploy.ts
@@ -2380,69 +2915,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)}`);
@@ -2464,6 +3198,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");
@@ -2490,12 +3242,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++;
@@ -2503,13 +3267,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++;
       }
@@ -2543,11 +3307,11 @@ async function deployWorkflows(config, client, stateManager, rootDir = process.c
     try {
       logger.info(`Processing: ${workflow.name}`);
       const yamlPath = path6.join(rootDir, workflow.definition);
-      if (!fs2.existsSync(yamlPath)) {
+      if (!fs6.existsSync(yamlPath)) {
         throw new Error(`Workflow definition file not found: ${workflow.definition}`);
       }
-      const yamlConfigContent = fs2.readFileSync(yamlPath, "utf8");
-      const workflowYaml = yaml3.parse(yamlConfigContent);
+      const yamlConfigContent = fs6.readFileSync(yamlPath, "utf8");
+      const workflowYaml = yaml5.parse(yamlConfigContent);
       const referencesToResolve = [];
       for (const assistant of workflowYaml.assistants) {
         const isInline = !assistant.assistant_name && assistant.model && assistant.system_prompt;
@@ -2588,7 +3352,7 @@ async function deployWorkflows(config, client, stateManager, rootDir = process.c
           });
         }
       }
-      const yamlConfig = yaml3.stringify(workflowYaml);
+      const yamlConfig = yaml5.stringify(workflowYaml);
       const workflowYamlChecksum = calculateChecksum(yamlConfigContent);
       const configChecksum = calculateWorkflowConfigChecksum(workflow);
       const existingState = stateManager.getWorkflowState(workflow.name);
@@ -2707,7 +3471,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(`
@@ -2721,12 +3485,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)
@@ -2753,6 +3520,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;
@@ -2790,10 +3562,37 @@ async function main2(options) {
   try {
     await deployResources(options);
     process.exit(0);
-  } catch {
+  } catch (error) {
+    logger.error("\n\u274C Deployment failed:");
+    logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 }
+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 = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+  const answer = await pauseSpinnerWhile(
+    () => new Promise((resolve6) => {
+      rl.question(displayQuestion, resolve6);
+    })
+  );
+  rl.close();
+  const trimmedAnswer = answer.trim();
+  return trimmedAnswer || defaultValue || "";
+}
+async function confirmOverwrite(filename) {
+  const answer = await promptUser(`File '${filename}' already exists. Overwrite? (y/n)`);
+  return answer.toLowerCase() === "y";
+}
+
+// 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");
@@ -2805,7 +3604,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");
@@ -2831,21 +3630,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 readline2 = await import('readline');
-      const rl = readline2.createInterface({
-        input: process.stdin,
-        output: process.stdout
-      });
-      const answer = await new Promise((resolve6) => {
-        rl.question('Type "destroy" to confirm deletion: ', resolve6);
-      });
-      rl.close();
+      const answer = await promptUser('Type "destroy" to confirm deletion');
       if (answer.trim().toLowerCase() !== "destroy") {
         logger.info("\n\u274C Destruction cancelled\n");
         return;
@@ -2855,7 +3652,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}`);
@@ -2888,27 +3685,349 @@ async function main3(options) {
     process.exit(1);
   }
 }
-async function promptUser(question, defaultValue) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const displayQuestion = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
-  const answer = await new Promise((resolve6) => {
-    rl.question(displayQuestion, resolve6);
+
+// 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 = path6.join(rootDir, "workflows", defFileName);
+      ensureDirectoryExists(defPath);
+      fs6.writeFileSync(defPath, workflow.yaml_config, "utf8");
+      logger.info(`   \u{1F4CB} Saved workflow definition: workflows/${defFileName}`);
+      workflowResource.definition = `workflows/${defFileName}`;
+    }
+    const configPath = path6.join(rootDir, "configs", "workflows", `${safeName}.yaml`);
+    const relativeConfigPath = `configs/workflows/${safeName}.yaml`;
+    ensureDirectoryExists(configPath);
+    const yamlContent2 = yaml5.stringify(workflowResource, { lineWidth: 120 });
+    fs6.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 = path6.join(rootDir, "configs", "imported-resources", pluralType);
+  const resourceFilePath = path6.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 = path6.join(rootDir, "system_prompts", `${promptFileName}.prompt.md`);
+      ensureDirectoryExists(promptPath);
+      fs6.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 = path6.join(rootDir, "skills", skillFileName);
+      ensureDirectoryExists(skillPath);
+      fs6.writeFileSync(skillPath, skill.content, "utf8");
+      logger.info(`   \u{1F9E0} Saved skill content: skills/${skillFileName}`);
+      skillResource.file = `skills/${skillFileName}`;
+    }
+  }
+  ensureDirectoryExists(resourceFilePath);
+  const yamlContent = yaml5.stringify(resource, { lineWidth: 120 });
+  fs6.writeFileSync(resourceFilePath, yamlContent, "utf8");
+  logger.info(`   \u{1F4C4} Saved resource config: ${relativeResourcePath}`);
+  return relativeResourcePath;
+}
+function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relativeResourcePath) {
+  const configPath = path6.join(rootDir, codemieConfigPath);
+  if (!fs6.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const content = fs6.readFileSync(configPath, "utf8");
+  const doc = yaml5.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 (yaml5.isMap(item)) {
+      const importValue = item.get("$import");
+      return importValue === relativeResourcePath;
+    }
+    return false;
   });
-  rl.close();
-  const trimmedAnswer = answer.trim();
-  return trimmedAnswer || defaultValue || "";
+  if (existingImports.length > 0) {
+    logger.info(`   \u21B7 Import directive already exists in ${codemieConfigPath}`);
+    return;
+  }
+  const newNode = doc.createNode(importDirective);
+  typeArray.add(newNode);
+  fs6.writeFileSync(configPath, doc.toString(), "utf8");
+  logger.info(`   \u2705 Added $import to ${codemieConfigPath} \u2192 resources.${pluralType}`);
 }
-async function confirmOverwrite(filename) {
-  const answer = await promptUser(`File '${filename}' already exists. Overwrite? (y/n)`);
-  return answer.toLowerCase() === "y";
+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;
+    }
+  }
 }
-
-// src/lib/initHelpers.ts
+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}"
+`);
+}
+async function main4(options) {
+  try {
+    await importResource(options);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`
+\u274C Import failed: ${errorMessage}
+`);
+    process.exitCode = 1;
+  }
+}
+init_logger();
 function fileExists(filePath) {
-  return fs2.existsSync(filePath);
+  return fs6.existsSync(filePath);
 }
 function generateEnvTemplate() {
   return `# Codemie API Configuration
@@ -2994,7 +4113,7 @@ async function saveConfigFile(config, defaultFilename = "config.json") {
       throw new Error(`Cancelled: Configuration file not saved.`);
     }
   }
-  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  fs6.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
   return configFilename;
 }
 function suggestConfigUsage(configFileName) {
@@ -3008,6 +4127,7 @@ function suggestConfigUsage(configFileName) {
 }
 
 // src/init.ts
+init_logger();
 async function initProject(options) {
   logger.info("\u{1F680} Initialize Codemie IaC Project\n\n");
   try {
@@ -3066,7 +4186,7 @@ async function initProject(options) {
     logger.info("\n\u{1F4C1} Creating configuration files...\n");
     if (shouldCreateEnv) {
       const envContent = generateEnvTemplate();
-      fs2.writeFileSync(envPath, envContent, "utf-8");
+      fs6.writeFileSync(envPath, envContent, "utf-8");
       logger.info(`\u2713 Created .env`);
       logger.warn(`  \u26A0\uFE0F  Remember to fill in your actual credentials!`);
       logger.warn(`  \u26A0\uFE0F  DO NOT commit .env to Git!
@@ -3074,7 +4194,7 @@ async function initProject(options) {
     }
     if (shouldCreateConfig) {
       const configContent = generateMinimalCodemieYaml(projectName, projectDescription);
-      fs2.writeFileSync(configPath, configContent, "utf-8");
+      fs6.writeFileSync(configPath, configContent, "utf-8");
       logger.info(`\u2713 Created ${appConfig.codemieConfig}`);
       logger.info(`  See examples/ directory for detailed configuration examples
 
@@ -3101,15 +4221,24 @@ async function initProject(options) {
     process.exit(1);
   }
 }
-async function main4(options) {
+async function main5(options) {
   await initProject(options);
 }
+
+// src/cli/index.ts
+init_commandSpinner();
+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,
@@ -3129,7 +4258,7 @@ async function previewResource(resource, resourceType, getState, checkExists, ca
       };
     }
   } else {
-    const { createDetails } = calculateChecksums();
+    const { createDetails } = await calculateChecksums();
     return {
       type: "create",
       resourceType,
@@ -3167,6 +4296,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) {
@@ -3205,10 +4370,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,
@@ -3229,10 +4403,10 @@ async function previewWorkflows(workflows, stateManager, client, rootDir = proce
   const changes = [];
   for (const workflow of workflows) {
     const yamlPath = path6.join(rootDir, workflow.definition);
-    if (!fs2.existsSync(yamlPath)) {
+    if (!fs6.existsSync(yamlPath)) {
       throw new Error(`Workflow definition file not found: ${workflow.definition}`);
     }
-    const yamlConfig = fs2.readFileSync(yamlPath, "utf8");
+    const yamlConfig = fs6.readFileSync(yamlPath, "utf8");
     const change = await previewResource(
       workflow,
       "workflow",
@@ -3267,6 +4441,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);
@@ -3294,7 +4472,7 @@ async function previewChanges(appConfig, existingClient) {
     }
   };
 }
-async function main5(options) {
+async function main6(options) {
   logger.info("\u{1F4CB} Generating deployment preview...\n");
   try {
     const { appConfig } = options;
@@ -3402,10 +4580,10 @@ var DependencyValidator = class {
     const errors = [];
     const visited = /* @__PURE__ */ new Set();
     const recursionStack = /* @__PURE__ */ new Set();
-    const dfs = (name, path15) => {
+    const dfs = (name, path16) => {
       if (recursionStack.has(name)) {
-        const cycleStart = path15.indexOf(name);
-        const cycle = [...path15.slice(cycleStart), name];
+        const cycleStart = path16.indexOf(name);
+        const cycle = [...path16.slice(cycleStart), name];
         errors.push(`Cyclic dependency detected: ${cycle.join(" \u2192 ")}`);
         return true;
       }
@@ -3414,14 +4592,14 @@ var DependencyValidator = class {
       }
       visited.add(name);
       recursionStack.add(name);
-      path15.push(name);
+      path16.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, [...path15])) {
+        if (dfs(subRef, [...path16])) {
           return true;
         }
       }
@@ -3480,7 +4658,7 @@ var DependencyValidator = class {
     }
     for (const workflow of workflows) {
       try {
-        const workflowYaml = yaml3.parse(workflow.definition);
+        const workflowYaml = yaml5.parse(workflow.definition);
         if (!workflowYaml.assistants) {
           continue;
         }
@@ -3504,6 +4682,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";
@@ -3586,11 +4767,11 @@ async function validateConfig(options) {
   if (config.resources.workflows && config.resources.workflows.length > 0) {
     const workflowsWithContent = config.resources.workflows.map((workflow) => {
       const workflowPath = path6.resolve(workflow.definition);
-      if (!fs2.existsSync(workflowPath)) {
+      if (!fs6.existsSync(workflowPath)) {
         errors.push(`Workflow definition file not found: ${workflow.definition}`);
         return { ...workflow, definition: "" };
       }
-      const definition = fs2.readFileSync(workflowPath, "utf8");
+      const definition = fs6.readFileSync(workflowPath, "utf8");
       return { ...workflow, definition };
     });
     const workflowErrors = DependencyValidator.validateWorkflowAssistantReferences(
@@ -3609,7 +4790,7 @@ async function validateConfig(options) {
   }
   return { success: errors.length === 0, errors };
 }
-async function main6(options) {
+async function main7(options) {
   const { checkApi = false, appConfig } = options;
   logger.info("\u{1F50D} Validating configuration...");
   if (checkApi) {
@@ -3656,31 +4837,47 @@ async function main6(options) {
 program.name("codemie").description("Infrastructure as Code for Codemie platform").version(package_default.version);
 program.command("init").description("Initialize a new Codemie IaC project").action(() => {
   const appConfig = loadAppConfig();
-  void main4({ appConfig });
+  void main5({ appConfig });
 });
-program.command("deploy").description("Deploy resources to Codemie platform").option("-p, --prune", "Delete orphaned resources").option("-c, --config <path>", "Configuration file").action((options) => {
+program.command("deploy").description("Deploy resources to Codemie platform").option("-p, --prune", "Delete orphaned resources").option("-c, --config <path>", "Configuration file").action(async (options) => {
   const configPath = options.config ? path6__default.resolve(options.config) : void 0;
   const appConfig = loadAppConfig(configPath);
-  void main2({ appConfig, prune: options.prune });
+  await runCommandWithSpinner("Deploying Codemie resources", () => main2({ appConfig, prune: options.prune }));
 });
-program.command("backup").description("Backup all resources from Codemie platform").option("-c, --config <path>", "Configuration file").action((options) => {
+program.command("backup").description("Backup all resources from Codemie platform").option("-c, --config <path>", "Configuration file").action(async (options) => {
   const configPath = options.config ? path6__default.resolve(options.config) : void 0;
   const appConfig = loadAppConfig(configPath);
-  void main({ appConfig });
+  await runCommandWithSpinner("Backing up Codemie resources", () => main({ appConfig }));
 });
-program.command("destroy").description("Destroy all IaC-managed resources").option("-f, --force", "Skip confirmation prompt").option("-c, --config <path>", "Configuration file").action((options) => {
+program.command("destroy").description("Destroy all IaC-managed resources").option("-f, --force", "Skip confirmation prompt").option("-c, --config <path>", "Configuration file").action(async (options) => {
   const configPath = options.config ? path6__default.resolve(options.config) : void 0;
   const appConfig = loadAppConfig(configPath);
-  void main3({ appConfig, force: options.force });
+  await runCommandWithSpinner("Destroying Codemie resources", () => main3({ appConfig, force: options.force }));
 });
-program.command("preview").description("Preview changes without applying them").option("-c, --config <path>", "Configuration file").action((options) => {
+program.command("preview").description("Preview changes without applying them").option("-c, --config <path>", "Configuration file").action(async (options) => {
   const appConfigPath = options.config ? path6__default.resolve(options.config) : void 0;
   const appConfig = loadAppConfig(appConfigPath);
-  void main5({ appConfig });
+  await runCommandWithSpinner("Generating Codemie preview", () => main6({ appConfig }));
+});
+program.command("validate").description("Validate configuration").option("-a, --check-api", "Check for API conflicts").option("-c, --config <path>", "Configuration file").action(async (options) => {
+  const configPath = options.config ? path6__default.resolve(options.config) : void 0;
+  const appConfig = loadAppConfig(configPath);
+  await runCommandWithSpinner(
+    "Validating Codemie configuration",
+    () => main7({ appConfig, checkApi: options.checkApi })
+  );
 });
-program.command("validate").description("Validate configuration").option("-a, --check-api", "Check for API conflicts").option("-c, --config <path>", "Configuration file").action((options) => {
+program.command("import").description("Import a single resource from the CodeMie platform into the local IaC configuration").argument("<type>", "Resource type: assistant, datasource, workflow, or skill").argument("<slug>", "Resource slug or name to import").option("-c, --config <path>", "Configuration file").action(async (type, slug, options) => {
+  const validTypes = ["assistant", "datasource", "workflow", "skill"];
+  if (!validTypes.includes(type)) {
+    process.exitCode = 1;
+    return;
+  }
   const configPath = options.config ? path6__default.resolve(options.config) : void 0;
   const appConfig = loadAppConfig(configPath);
-  void main6({ appConfig, checkApi: options.checkApi });
+  await runCommandWithSpinner(
+    `Importing ${type}`,
+    () => main4({ appConfig, resourceType: type, slug })
+  );
 });
 program.parse();