@codemieai/cdk 0.1.632 → 0.1.633

package/dist/cli/index.js

@@ -2,10 +2,10 @@
 import ora from 'ora';
 import * as crypto from 'crypto';
 import { DataSourceType, CodeMieClient, SkillVisibility } from 'codemie-sdk';
-import * as fs6 from 'fs';
-import * as path6 from 'path';
-import path6__default from 'path';
-import * as yaml5 from 'yaml';
+import * as fs11 from 'fs';
+import * as path16 from 'path';
+import path16__default from 'path';
+import * as yaml6 from 'yaml';
 import { program } from '@commander-js/extra-typings';
 import { z } from 'zod';
 import 'dotenv/config';
@@ -751,15 +751,15 @@ function sanitizeFileName(name, maxLength = 255) {
 }
 function validateBackupDirectory(backupDir, minSpaceGB = 1) {
   try {
-    const parentDir = path6.dirname(backupDir);
-    if (!fs6.existsSync(parentDir)) {
-      fs6.mkdirSync(parentDir, { recursive: true });
+    const parentDir = path16.dirname(backupDir);
+    if (!fs11.existsSync(parentDir)) {
+      fs11.mkdirSync(parentDir, { recursive: true });
     }
-    const testFile = path6.join(parentDir, ".write-test");
-    fs6.writeFileSync(testFile, "test");
-    fs6.unlinkSync(testFile);
+    const testFile = path16.join(parentDir, ".write-test");
+    fs11.writeFileSync(testFile, "test");
+    fs11.unlinkSync(testFile);
     try {
-      const stats = fs6.statfsSync(parentDir);
+      const stats = fs11.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`);
@@ -775,7 +775,7 @@ function validateBackupDirectory(backupDir, minSpaceGB = 1) {
 }
 function moveAtomically(tempPath, finalPath) {
   try {
-    fs6.renameSync(tempPath, finalPath);
+    fs11.renameSync(tempPath, finalPath);
   } catch (error) {
     const err = error;
     if (err.code === "EEXIST") {
@@ -785,14 +785,14 @@ function moveAtomically(tempPath, finalPath) {
   }
 }
 function cleanupDirectory(dirPath) {
-  if (fs6.existsSync(dirPath)) {
-    fs6.rmSync(dirPath, { recursive: true, force: true });
+  if (fs11.existsSync(dirPath)) {
+    fs11.rmSync(dirPath, { recursive: true, force: true });
   }
 }
 function ensureDirectoryExists(filePath) {
-  const dir = path6.dirname(filePath);
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
+  const dir = path16.dirname(filePath);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
 }
 var BYTES_IN_GB;
@@ -931,7 +931,7 @@ function prepareWorkflowForYaml(workflow, state, assistants, backupDir) {
   let finalYamlContent = yamlConfig || "";
   if (yamlConfig) {
     try {
-      const workflowYaml = yaml5.parse(yamlConfig);
+      const workflowYaml = yaml6.parse(yamlConfig);
       const transformedAssistants = workflowYaml.assistants?.map((assistant) => {
         if (assistant.assistant_id && typeof assistant.assistant_id === "string") {
           const assistantId = assistant.assistant_id;
@@ -946,10 +946,10 @@ function prepareWorkflowForYaml(workflow, state, assistants, backupDir) {
       if (transformedAssistants) {
         const transformedYaml = { ...workflowYaml, assistants: transformedAssistants };
         const fileName = `${sanitizeFileName(workflow.name)}.yaml`;
-        const filePath = path6.join(backupDir, "workflows", fileName);
+        const filePath = path16.join(backupDir, "workflows", fileName);
         ensureDirectoryExists(filePath);
-        finalYamlContent = yaml5.stringify(transformedYaml);
-        fs6.writeFileSync(filePath, finalYamlContent, "utf8");
+        finalYamlContent = yaml6.stringify(transformedYaml);
+        fs11.writeFileSync(filePath, finalYamlContent, "utf8");
       }
     } catch (error) {
       logger.warn(
@@ -1023,7 +1023,7 @@ var init_backupTransformers = __esm({
 
 // package.json
 var package_default = {
-  version: "0.1.632"};
+  version: "0.1.633"};
 var appConfigSchema = z.object({
   rootDir: z.string(),
   codemieConfig: z.string(),
@@ -1041,23 +1041,49 @@ var defaultConfig = {
 };
 
 // src/appConfig/configLoader.ts
-function loadAppConfig(userConfigPath) {
-  if (!userConfigPath) {
-    return defaultConfig;
+init_logger();
+var PROJECT_MARKER_FILE = "codemie.yaml";
+function loadAppConfig(userConfigPath, rootDir) {
+  if (userConfigPath) {
+    const userConfig = loadUserConfig(userConfigPath);
+    const sanitizedUserConfig = removeEmptyFields(userConfig);
+    const merged = { ...defaultConfig, ...sanitizedUserConfig };
+    if (sanitizedUserConfig.rootDir === void 0 && rootDir) {
+      merged.rootDir = path16.resolve(rootDir);
+    }
+    return appConfigSchema.parse(merged);
+  }
+  if (rootDir) {
+    return { ...defaultConfig, rootDir: path16.resolve(rootDir) };
+  }
+  const detectedRoot = findProjectRoot(process.cwd());
+  if (detectedRoot) {
+    logger.info(`Using detected project root: ${detectedRoot}`);
+    return { ...defaultConfig, rootDir: detectedRoot };
+  }
+  return defaultConfig;
+}
+function findProjectRoot(startDir) {
+  let dir = path16.resolve(startDir);
+  while (true) {
+    if (fs11.existsSync(path16.join(dir, PROJECT_MARKER_FILE))) {
+      return dir;
+    }
+    const parentDir = path16.dirname(dir);
+    if (parentDir === dir || dir === path16.parse(dir).root) {
+      return null;
+    }
+    dir = parentDir;
   }
-  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)) {
+  const resolvedPath = path16.resolve(process.cwd(), configPath);
+  if (!fs11.existsSync(resolvedPath)) {
     throw new Error(`Config file not found: ${resolvedPath}`);
   }
   let raw;
   try {
-    raw = fs6.readFileSync(resolvedPath, "utf8");
+    raw = fs11.readFileSync(resolvedPath, "utf8");
   } catch (error) {
     throw new Error(`Failed to read config file: ${resolvedPath}`, { cause: error });
   }
@@ -1119,9 +1145,9 @@ var BackupTransaction = class {
   isDirty = false;
   saveTimer;
   constructor(backupDir, transactionId) {
-    this.transactionPath = path6.join(backupDir, "transaction.json");
+    this.transactionPath = path16.join(backupDir, "transaction.json");
     try {
-      const content = fs6.readFileSync(this.transactionPath, "utf8");
+      const content = fs11.readFileSync(this.transactionPath, "utf8");
       this.data = JSON.parse(content);
       logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id}`);
     } catch (error) {
@@ -1153,9 +1179,9 @@ var BackupTransaction = class {
   }
   writeTransactionExclusively(data) {
     try {
-      const fd = fs6.openSync(this.transactionPath, "wx");
-      fs6.writeSync(fd, JSON.stringify(data, null, 2));
-      fs6.closeSync(fd);
+      const fd = fs11.openSync(this.transactionPath, "wx");
+      fs11.writeSync(fd, JSON.stringify(data, null, 2));
+      fs11.closeSync(fd);
     } catch (writeError) {
       const writeErr = writeError;
       if (writeErr.code === "EEXIST") {
@@ -1174,7 +1200,7 @@ var BackupTransaction = class {
         if (delayMs > 0) {
           busyWaitDelay(delayMs);
         }
-        const content = fs6.readFileSync(this.transactionPath, "utf8");
+        const content = fs11.readFileSync(this.transactionPath, "utf8");
         this.data = JSON.parse(content);
         logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id} (created by concurrent process)`);
         break;
@@ -1197,7 +1223,7 @@ var BackupTransaction = class {
    */
   async save() {
     ensureDirectoryExists(this.transactionPath);
-    const savePromise = fs6.promises.writeFile(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
+    const savePromise = fs11.promises.writeFile(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
     let timeoutId;
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(
@@ -1223,7 +1249,7 @@ var BackupTransaction = class {
    */
   saveSyncInternal() {
     ensureDirectoryExists(this.transactionPath);
-    fs6.writeFileSync(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
+    fs11.writeFileSync(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
     this.isDirty = false;
   }
   /**
@@ -1334,8 +1360,8 @@ var BackupTransaction = class {
    * Clean up transaction file after successful completion
    */
   cleanup() {
-    if (fs6.existsSync(this.transactionPath)) {
-      fs6.unlinkSync(this.transactionPath);
+    if (fs11.existsSync(this.transactionPath)) {
+      fs11.unlinkSync(this.transactionPath);
     }
   }
 };
@@ -1425,10 +1451,10 @@ function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPath
       }
     }
   };
-  return yaml5.stringify(config);
+  return yaml6.stringify(config);
 }
 function saveIntegrationOpenApiSpecs(backupData, backupDir) {
-  const specsDir = path6.join(backupDir, "openapi_specs");
+  const specsDir = path16.join(backupDir, "openapi_specs");
   let specsCount = 0;
   const integrationSpecPaths = /* @__PURE__ */ new Map();
   for (const integration of backupData.resources.integrations) {
@@ -1441,8 +1467,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 (!fs6.existsSync(specsDir)) {
-        fs6.mkdirSync(specsDir, { recursive: true });
+      if (!fs11.existsSync(specsDir)) {
+        fs11.mkdirSync(specsDir, { recursive: true });
       }
       const specContent = specEntry.value;
       let fileExtension = ".yaml";
@@ -1455,8 +1481,8 @@ function saveIntegrationOpenApiSpecs(backupData, backupDir) {
         fileExtension = ".yaml";
       }
       const specFileName = `${fileName}${fileExtension}`;
-      const specPath = path6.join(specsDir, specFileName);
-      fs6.writeFileSync(specPath, contentToSave, "utf8");
+      const specPath = path16.join(specsDir, specFileName);
+      fs11.writeFileSync(specPath, contentToSave, "utf8");
       integrationSpecPaths.set(integration.id, `openapi_specs/${specFileName}`);
       specsCount++;
     }
@@ -1469,15 +1495,15 @@ function saveIntegrationOpenApiSpecs(backupData, backupDir) {
 function saveBackupFiles(backupData, backupDir, projectName) {
   logger.info("\u{1F4BE} Writing backup files...\n");
   const integrationSpecPaths = saveIntegrationOpenApiSpecs(backupData, backupDir);
-  const codemieYamlPath = path6.join(backupDir, "codemie.yaml");
+  const codemieYamlPath = path16.join(backupDir, "codemie.yaml");
   const codemieYaml = generateCodemieYaml(backupData, projectName, backupDir, integrationSpecPaths);
-  fs6.writeFileSync(codemieYamlPath, codemieYaml, "utf8");
+  fs11.writeFileSync(codemieYamlPath, codemieYaml, "utf8");
   logger.info(`   \u2713 Saved config file: codemie.yaml`);
-  const backupJsonPath = path6.join(backupDir, "backup.json");
-  fs6.writeFileSync(backupJsonPath, JSON.stringify(backupData, null, 2), "utf8");
+  const backupJsonPath = path16.join(backupDir, "backup.json");
+  fs11.writeFileSync(backupJsonPath, JSON.stringify(backupData, null, 2), "utf8");
   logger.info(`   \u2713 Saved full backup: backup.json`);
-  const statePath = path6.join(backupDir, "state.json");
-  fs6.writeFileSync(statePath, JSON.stringify(backupData.state, null, 2), "utf8");
+  const statePath = path16.join(backupDir, "state.json");
+  fs11.writeFileSync(statePath, JSON.stringify(backupData.state, null, 2), "utf8");
   logger.info(`   \u2713 Saved state file: state.json`);
 }
 async function createClient(config) {
@@ -1507,6 +1533,141 @@ function namesEqual(a, b) {
   return a.toLowerCase() === b.toLowerCase();
 }
 
+// src/lib/configImports.ts
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveImports(obj, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
+  if (!isPlainObject3(obj)) {
+    return;
+  }
+  for (const key in obj) {
+    const value = obj[key];
+    if (isPlainObject3(value) && "$import" in value) {
+      const importDirective = value;
+      const importPath = path16.join(baseDir, importDirective.$import);
+      const normalizedPath = path16.resolve(importPath);
+      if (visitedFiles.has(normalizedPath)) {
+        throw new Error(
+          `Circular import detected: ${normalizedPath}
+Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
+        );
+      }
+      visitedFiles.add(normalizedPath);
+      const imported = loadYamlFile(importPath);
+      obj[key] = imported;
+      resolveImports(obj[key], path16.dirname(importPath), visitedFiles);
+      visitedFiles.delete(normalizedPath);
+    } else if (Array.isArray(value)) {
+      obj[key] = resolveArrayImports(value, baseDir, visitedFiles);
+    } else if (isPlainObject3(value)) {
+      resolveImports(value, baseDir, visitedFiles);
+    }
+  }
+}
+function resolveArrayImports(arr, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
+  const result = [];
+  for (const item of arr) {
+    if (isPlainObject3(item) && "$import" in item) {
+      const importDirective = item;
+      const importPath = path16.join(baseDir, importDirective.$import);
+      const normalizedPath = path16.resolve(importPath);
+      if (visitedFiles.has(normalizedPath)) {
+        throw new Error(
+          `Circular import detected: ${normalizedPath}
+Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
+        );
+      }
+      visitedFiles.add(normalizedPath);
+      const imported = loadYamlFile(importPath);
+      if (Array.isArray(imported)) {
+        const resolvedArray = resolveArrayImports(imported, path16.dirname(importPath), visitedFiles);
+        for (const resolvedItem of resolvedArray) {
+          result.push(resolvedItem);
+        }
+      } else if (isPlainObject3(imported)) {
+        result.push(imported);
+        resolveImports(imported, path16.dirname(importPath), visitedFiles);
+      } else {
+        throw new TypeError(
+          `Import file ${importPath} must contain either an object or an array. Got: ${typeof imported}`
+        );
+      }
+      visitedFiles.delete(normalizedPath);
+    } else {
+      result.push(item);
+      if (isPlainObject3(item)) {
+        resolveImports(item, baseDir, visitedFiles);
+      }
+    }
+  }
+  return result;
+}
+function loadYamlFile(filePath) {
+  if (!fs11.existsSync(filePath)) {
+    throw new Error(`Import file not found: ${filePath}`);
+  }
+  try {
+    const content = fs11.readFileSync(filePath, "utf8");
+    const parsed = yaml6.parse(content);
+    if (parsed === null || parsed === void 0) {
+      throw new TypeError(`Import file ${filePath} is empty`);
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to parse YAML file ${filePath}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function findResourceDefinition(rootDir, codemieConfigPath, plural, name) {
+  const configPath = path16.join(rootDir, codemieConfigPath);
+  const config = loadYamlFile(configPath);
+  if (!isPlainObject3(config) || !isPlainObject3(config.resources)) {
+    return void 0;
+  }
+  const list = config.resources[plural];
+  if (!Array.isArray(list)) {
+    return void 0;
+  }
+  return findResourceInList(list, rootDir, null, name, /* @__PURE__ */ new Set());
+}
+function findResourceInList(items, baseDir, currentFile, name, visitedFiles) {
+  for (const item of items) {
+    if (!isPlainObject3(item)) {
+      continue;
+    }
+    if (typeof item.$import === "string") {
+      const importPath = path16.join(baseDir, item.$import);
+      const normalizedPath = path16.resolve(importPath);
+      if (visitedFiles.has(normalizedPath)) {
+        throw new Error(
+          `Circular import detected: ${normalizedPath}
+Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
+        );
+      }
+      visitedFiles.add(normalizedPath);
+      const loaded = loadYamlFile(importPath);
+      let found;
+      if (Array.isArray(loaded)) {
+        found = findResourceInList(loaded, path16.dirname(importPath), normalizedPath, name, visitedFiles);
+      } else if (isPlainObject3(loaded) && typeof loaded.name === "string" && namesEqual(loaded.name, name)) {
+        found = { file: normalizedPath, resource: loaded, inList: false };
+      }
+      visitedFiles.delete(normalizedPath);
+      if (found) {
+        return found;
+      }
+      continue;
+    }
+    if (typeof item.name === "string" && namesEqual(item.name, name)) {
+      return { file: currentFile, resource: item, inList: true };
+    }
+  }
+  return void 0;
+}
+
 // src/lib/codemieConfigLoader.ts
 var CodemieConfigLoader = class {
   appConfig;
@@ -1518,13 +1679,13 @@ var CodemieConfigLoader = class {
    */
   loadConfig() {
     const { rootDir, codemieConfig } = this.appConfig;
-    const configPath = path6.join(rootDir, codemieConfig);
-    if (!fs6.existsSync(configPath)) {
+    const configPath = path16.join(rootDir, codemieConfig);
+    if (!fs11.existsSync(configPath)) {
       throw new Error(`Configuration file not found: ${configPath}`);
     }
-    const content = fs6.readFileSync(configPath, "utf8");
-    const config = yaml5.parse(content);
-    this.resolveImports(config, rootDir);
+    const content = fs11.readFileSync(configPath, "utf8");
+    const config = yaml6.parse(content);
+    resolveImports(config, rootDir);
     this.substituteEnvVars(config);
     this.applyDatasourceDefaults(config);
     this.resolveReferencesRecursive(config, config);
@@ -1536,34 +1697,34 @@ var CodemieConfigLoader = class {
    */
   loadPrompt(promptPath) {
     const { rootDir } = this.appConfig;
-    const fullPath = path6.join(rootDir, promptPath);
-    if (!fs6.existsSync(fullPath)) {
+    const fullPath = path16.join(rootDir, promptPath);
+    if (!fs11.existsSync(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
-    return fs6.readFileSync(fullPath, "utf8");
+    return fs11.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)) {
+    const fullPath = path16.join(rootDir, contentPath);
+    if (!fs11.existsSync(fullPath)) {
       throw new Error(`Skill content file not found: ${fullPath}`);
     }
-    return fs6.readFileSync(fullPath, "utf8");
+    return fs11.readFileSync(fullPath, "utf8");
   }
   /**
    * Load assistant configuration file
    */
   loadAssistantConfig(configPath) {
     const { rootDir } = this.appConfig;
-    const fullPath = path6.join(rootDir, configPath);
-    if (!fs6.existsSync(fullPath)) {
+    const fullPath = path16.join(rootDir, configPath);
+    if (!fs11.existsSync(fullPath)) {
       throw new Error(`Config file not found: ${fullPath}`);
     }
-    const content = fs6.readFileSync(fullPath, "utf8");
-    return yaml5.parse(content);
+    const content = fs11.readFileSync(fullPath, "utf8");
+    return yaml6.parse(content);
   }
   /**
    * Validate that all referenced files exist
@@ -1573,13 +1734,14 @@ var CodemieConfigLoader = class {
     const { rootDir } = this.appConfig;
     if (config.resources.assistants) {
       for (const assistant of config.resources.assistants) {
-        const promptPath = path6.join(rootDir, assistant.prompt);
-        if (!fs6.existsSync(promptPath)) {
+        if (!assistant.prompt) {
+          errors.push(`Missing 'prompt' for assistant: ${assistant.name}`);
+        } else if (!fs11.existsSync(path16.join(rootDir, assistant.prompt))) {
           errors.push(`Prompt file not found for ${assistant.name}: ${assistant.prompt}`);
         }
         if (assistant.config) {
-          const configPath = path6.join(rootDir, assistant.config);
-          if (!fs6.existsSync(configPath)) {
+          const configPath = path16.join(rootDir, assistant.config);
+          if (!fs11.existsSync(configPath)) {
             errors.push(`Config file not found for ${assistant.name}: ${assistant.config}`);
           }
         }
@@ -1593,8 +1755,9 @@ 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)) {
+        if (!skill.file) {
+          errors.push(`Missing 'file' for skill: ${skill.name}`);
+        } else if (!fs11.existsSync(path16.join(rootDir, skill.file))) {
           errors.push(`Content file not found for skill ${skill.name}: ${skill.file}`);
         }
         if (!skill.description) {
@@ -1615,109 +1778,6 @@ var CodemieConfigLoader = class {
       errors
     };
   }
-  /**
-   * Resolve $import directives recursively
-   * Automatically handles:
-   * 1. Single resource import (object)
-   * 2. Multiple resources import (array)
-   * 3. Mixed inline + imports
-   * Includes circular import detection to prevent infinite recursion
-   */
-  resolveImports(obj, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
-    if (!this.isPlainObject(obj)) {
-      return;
-    }
-    for (const key in obj) {
-      const value = obj[key];
-      if (this.isPlainObject(value) && "$import" in value) {
-        const importDirective = value;
-        const importPath = path6.join(baseDir, importDirective.$import);
-        const normalizedPath = path6.resolve(importPath);
-        if (visitedFiles.has(normalizedPath)) {
-          throw new Error(
-            `Circular import detected: ${normalizedPath}
-Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
-          );
-        }
-        visitedFiles.add(normalizedPath);
-        const imported = this.loadYamlFile(importPath);
-        obj[key] = imported;
-        this.resolveImports(obj[key], path6.dirname(importPath), visitedFiles);
-        visitedFiles.delete(normalizedPath);
-      } else if (Array.isArray(value)) {
-        obj[key] = this.resolveArrayImports(value, baseDir, visitedFiles);
-      } else if (this.isPlainObject(value)) {
-        this.resolveImports(value, baseDir, visitedFiles);
-      }
-    }
-  }
-  /**
-   * Resolve imports in arrays
-   * Intelligently handles:
-   * - Inline objects (keep as-is)
-   * - $import with single object (add to array)
-   * - $import with array (flatten into parent array)
-   * Includes circular import detection
-   */
-  resolveArrayImports(arr, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
-    const result = [];
-    for (const item of arr) {
-      if (this.isPlainObject(item) && "$import" in item) {
-        const importDirective = item;
-        const importPath = path6.join(baseDir, importDirective.$import);
-        const normalizedPath = path6.resolve(importPath);
-        if (visitedFiles.has(normalizedPath)) {
-          throw new Error(
-            `Circular import detected: ${normalizedPath}
-Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
-          );
-        }
-        visitedFiles.add(normalizedPath);
-        const imported = this.loadYamlFile(importPath);
-        if (Array.isArray(imported)) {
-          const resolvedArray = this.resolveArrayImports(imported, path6.dirname(importPath), visitedFiles);
-          for (const resolvedItem of resolvedArray) {
-            result.push(resolvedItem);
-          }
-        } else if (this.isPlainObject(imported)) {
-          result.push(imported);
-          this.resolveImports(imported, path6.dirname(importPath), visitedFiles);
-        } else {
-          throw new TypeError(
-            `Import file ${importPath} must contain either an object or an array. Got: ${typeof imported}`
-          );
-        }
-        visitedFiles.delete(normalizedPath);
-      } else {
-        result.push(item);
-        if (this.isPlainObject(item)) {
-          this.resolveImports(item, baseDir, visitedFiles);
-        }
-      }
-    }
-    return result;
-  }
-  /**
-   * Load YAML file with error handling
-   */
-  loadYamlFile(filePath) {
-    if (!fs6.existsSync(filePath)) {
-      throw new Error(`Import file not found: ${filePath}`);
-    }
-    try {
-      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`);
-      }
-      return parsed;
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new TypeError(`Failed to parse YAML file ${filePath}: ${error.message}`);
-      }
-      throw error;
-    }
-  }
   /**
    * Recursively resolve all $ref in an object/array structure
    * Handles both object references { $ref: "path" } and string references "$ref:path"
@@ -1726,28 +1786,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, path16 = "") {
+  resolveReferencesRecursive(current, rootConfig, path17 = "") {
     if (!current || typeof current !== "object") {
       return;
     }
     if (Array.isArray(current)) {
-      this.resolveArrayReferences(current, rootConfig, path16);
+      this.resolveArrayReferences(current, rootConfig, path17);
       return;
     }
     if ("$ref" in current && typeof current.$ref === "string") {
-      this.resolveObjectReference(current, rootConfig, path16);
+      this.resolveObjectReference(current, rootConfig, path17);
       return;
     }
-    this.resolveObjectProperties(current, rootConfig, path16);
+    this.resolveObjectProperties(current, rootConfig, path17);
   }
   /**
    * 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, path16) {
+  resolveArrayReferences(arr, rootConfig, path17) {
     const result = arr.flatMap((item, i) => {
-      const contextPath = `${path16}[${i}]`;
+      const contextPath = `${path17}[${i}]`;
       if (!this.isRefObject(item) || item.$ref.startsWith("#")) {
         this.resolveReferencesRecursive(item, rootConfig, contextPath);
         return [item];
@@ -1765,9 +1825,9 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
    * Resolve object reference: { $ref: "path" }
    * Replaces object with resolved data (in-place mutation)
    */
-  resolveObjectReference(current, rootConfig, path16) {
+  resolveObjectReference(current, rootConfig, path17) {
     const refPath = current.$ref;
-    const contextPath = path16 || "root";
+    const contextPath = path17 || "root";
     if (refPath.startsWith("#")) {
       return;
     }
@@ -1777,24 +1837,24 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
       delete current[key];
     }
     Object.assign(current, filteredResolved);
-    this.resolveReferencesRecursive(current, rootConfig, path16);
+    this.resolveReferencesRecursive(current, rootConfig, path17);
   }
   /**
    * Resolve object properties recursively
    * Handles both nested objects and "$ref:path" string references
    */
-  resolveObjectProperties(current, rootConfig, path16) {
+  resolveObjectProperties(current, rootConfig, path17) {
     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 = path16 ? `${path16}.${key}` : key;
+        const contextPath = path17 ? `${path17}.${key}` : key;
         const resolved = this.resolveReference(rootConfig, refPath, contextPath);
         current[key] = resolved;
       } else {
-        this.resolveReferencesRecursive(value, rootConfig, path16 ? `${path16}.${key}` : key);
+        this.resolveReferencesRecursive(value, rootConfig, path17 ? `${path17}.${key}` : key);
       }
     }
   }
@@ -2045,9 +2105,9 @@ async function saveAssistantToBackup(assistant, client, backupData, backupDir) {
   backupData.resources.assistants.push(full);
   if (full.system_prompt) {
     const fileName = `${full.slug || sanitizeFileName(full.name)}.prompt.md`;
-    const filePath = path6.join(backupDir, "system_prompts", fileName);
+    const filePath = path16.join(backupDir, "system_prompts", fileName);
     ensureDirectoryExists(filePath);
-    fs6.writeFileSync(filePath, full.system_prompt, "utf8");
+    fs11.writeFileSync(filePath, full.system_prompt, "utf8");
   }
 }
 async function backupAssistants(client, backupData, backupDir, transaction) {
@@ -2173,9 +2233,9 @@ async function backupWorkflows(client, backupData, backupDir, transaction) {
       backupData.resources.workflows.push(full);
       if (full.yaml_config) {
         const fileName = `${sanitizeFileName(full.name)}.yaml`;
-        const filePath = path6.join(backupDir, "workflows", fileName);
+        const filePath = path16.join(backupDir, "workflows", fileName);
         ensureDirectoryExists(filePath);
-        fs6.writeFileSync(filePath, full.yaml_config, "utf8");
+        fs11.writeFileSync(filePath, full.yaml_config, "utf8");
       }
       transaction.markCompleted("workflows", workflow.id);
     } catch (error) {
@@ -2278,9 +2338,9 @@ async function backupSkills(client, backupData, backupDir, transaction, projectN
           backupData.resources.skills.push(full);
           if (fullIsProjectOwned) {
             const fileName = `${sanitizeFileName(skill.name)}.skill.md`;
-            const filePath = path6.join(backupDir, "skills", fileName);
+            const filePath = path16.join(backupDir, "skills", fileName);
             ensureDirectoryExists(filePath);
-            fs6.writeFileSync(filePath, full.content || "", "utf8");
+            fs11.writeFileSync(filePath, full.content || "", "utf8");
           } else {
             logger.info(`     \u21B7 Skipping content file for imported skill ${skill.name} (owner: ${full.project})`);
           }
@@ -2302,17 +2362,17 @@ async function backupSkills(client, backupData, backupDir, transaction, projectN
 }
 function getUniqueBackupDir(baseDir, timestamp) {
   let counter = 0;
-  let finalBackupDir = path6.join(baseDir, timestamp);
-  while (fs6.existsSync(finalBackupDir)) {
+  let finalBackupDir = path16.join(baseDir, timestamp);
+  while (fs11.existsSync(finalBackupDir)) {
     counter++;
-    finalBackupDir = path6.join(baseDir, `${timestamp}-${counter}`);
+    finalBackupDir = path16.join(baseDir, `${timestamp}-${counter}`);
   }
   const dirSuffix = counter > 0 ? `${timestamp}-${counter}` : timestamp;
-  const tempBackupDir = path6.join(baseDir, `${BACKUP.TEMP_DIR_PREFIX}${dirSuffix}`);
+  const tempBackupDir = path16.join(baseDir, `${BACKUP.TEMP_DIR_PREFIX}${dirSuffix}`);
   return { finalDir: finalBackupDir, tempDir: tempBackupDir };
 }
 function performCleanup(tempBackupDir, transaction) {
-  if (fs6.existsSync(tempBackupDir)) {
+  if (fs11.existsSync(tempBackupDir)) {
     try {
       logger.info(`\u{1F9F9} Rolling back: cleaning up ${tempBackupDir}...`);
       cleanupDirectory(tempBackupDir);
@@ -2341,7 +2401,7 @@ async function backupResources(options) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "").replaceAll(":", "-");
   const { appConfig } = options;
   const { rootDir, backupsDirectory } = appConfig;
-  const backupBaseDir = path6.join(rootDir, backupsDirectory);
+  const backupBaseDir = path16.join(rootDir, backupsDirectory);
   const { finalDir: finalBackupDir, tempDir: tempBackupDir } = getUniqueBackupDir(backupBaseDir, timestamp);
   let transaction = null;
   try {
@@ -2351,8 +2411,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 (!fs6.existsSync(tempBackupDir)) {
-      fs6.mkdirSync(tempBackupDir, { recursive: true });
+    if (!fs11.existsSync(tempBackupDir)) {
+      fs11.mkdirSync(tempBackupDir, { recursive: true });
     }
     logger.info(`\u{1F4C1} Temporary backup directory: ${tempBackupDir}
 `);
@@ -2933,16 +2993,16 @@ var StateManager = class {
   statePath;
   constructor(appConfig) {
     const { rootDir, codemieState } = appConfig;
-    this.statePath = path6.join(rootDir, codemieState);
+    this.statePath = path16.join(rootDir, codemieState);
   }
   /**
    * Load state file
    */
   loadState() {
-    if (!fs6.existsSync(this.statePath)) {
+    if (!fs11.existsSync(this.statePath)) {
       return this.createEmptyState();
     }
-    const content = fs6.readFileSync(this.statePath, "utf8");
+    const content = fs11.readFileSync(this.statePath, "utf8");
     const state = JSON.parse(content);
     if (!state.resources) {
       state.resources = {
@@ -2970,12 +3030,12 @@ var StateManager = class {
    * Save state file
    */
   saveState(state) {
-    const dir = path6.dirname(this.statePath);
-    if (!fs6.existsSync(dir)) {
-      fs6.mkdirSync(dir, { recursive: true });
+    const dir = path16.dirname(this.statePath);
+    if (!fs11.existsSync(dir)) {
+      fs11.mkdirSync(dir, { recursive: true });
     }
     state.lastSync = (/* @__PURE__ */ new Date()).toISOString();
-    fs6.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
+    fs11.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
   }
   /**
    * Create empty state structure
@@ -3674,12 +3734,12 @@ async function deployWorkflows(config, client, stateManager, rootDir = process.c
   for (const workflow of config.resources.workflows) {
     try {
       logger.info(`Processing: ${workflow.name}`);
-      const yamlPath = path6.join(rootDir, workflow.definition);
-      if (!fs6.existsSync(yamlPath)) {
+      const yamlPath = path16.join(rootDir, workflow.definition);
+      if (!fs11.existsSync(yamlPath)) {
         throw new Error(`Workflow definition file not found: ${workflow.definition}`);
       }
-      const yamlConfigContent = fs6.readFileSync(yamlPath, "utf8");
-      const workflowYaml = yaml5.parse(yamlConfigContent);
+      const yamlConfigContent = fs11.readFileSync(yamlPath, "utf8");
+      const workflowYaml = yaml6.parse(yamlConfigContent);
       const referencesToResolve = [];
       for (const assistant of workflowYaml.assistants ?? []) {
         const isInline = !assistant.assistant_name && assistant.model && assistant.system_prompt;
@@ -3720,7 +3780,7 @@ async function deployWorkflows(config, client, stateManager, rootDir = process.c
           });
         }
       }
-      const yamlConfig = yaml5.stringify(workflowYaml);
+      const yamlConfig = yaml6.stringify(workflowYaml);
       const workflowYamlChecksum = calculateChecksum(yamlConfigContent);
       const configChecksum = calculateWorkflowConfigChecksum(workflow);
       const existingState = stateManager.getWorkflowState(workflow.name);
@@ -4050,14 +4110,34 @@ async function main3(options) {
 }
 
 // src/import.ts
+init_checksumUtils();
+init_codemieConfigChecksums();
 init_converters();
-init_skillUtils();
 init_fileUtils();
 init_logger();
-init_checksumUtils();
-init_codemieConfigChecksums();
+
+// src/lib/resourceTypes.ts
 var VALID_RESOURCE_TYPES = ["assistant", "datasource", "workflow", "skill"];
+var PLURAL_BY_RESOURCE_TYPE = {
+  assistant: "assistants",
+  datasource: "datasources",
+  workflow: "workflows",
+  skill: "skills"
+};
+function pluralTypeOf(resourceType) {
+  return PLURAL_BY_RESOURCE_TYPE[resourceType];
+}
+
+// src/import.ts
+init_skillUtils();
 async function findAssistant(client, slug) {
+  if (UUID_RE.test(slug)) {
+    return withTimeout(
+      client.assistants.get(slug),
+      TIMEOUTS_MS.ASSISTANT_FETCH,
+      `Timeout fetching assistant "${slug}"`
+    );
+  }
   try {
     const assistant = await withTimeout(
       client.assistants.getBySlug(slug),
@@ -4141,7 +4221,7 @@ 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 pluralType = pluralTypeOf(resourceType);
   const resources = config.resources[pluralType] || [];
   if (resources.some((r) => namesEqual(r.name, name))) {
     return true;
@@ -4152,68 +4232,252 @@ function checkResourceExists2(config, resourceType, name) {
   }
   return false;
 }
+function findManagedNameById(stateManager, resourceType, id) {
+  const state = stateManager.loadState();
+  const pluralType = pluralTypeOf(resourceType);
+  const resources = state.resources[pluralType] || {};
+  const matches = Object.keys(resources).filter((name) => resources[name]?.id === id);
+  if (matches.length > 1) {
+    throw new Error(
+      `state.json is ambiguous: ${matches.length} ${pluralType} entries share platform id ${id} (${matches.map((name) => `"${name}"`).join(", ")}). Remove the duplicate entries so this ${resourceType} can be matched unambiguously.`
+    );
+  }
+  return matches[0];
+}
+function nameClashError(resourceType, name) {
+  return new Error(
+    `A ${resourceType} named "${name}" already exists in the configuration. Re-run with --update to replace it with the platform version, or remove it first.`
+  );
+}
+function assertResolvedNameIsFree(config, stateManager, resourceType, slug, resolvedName, id, update) {
+  if (!update && !namesEqual(slug, resolvedName) && checkResourceExists2(config, resourceType, resolvedName)) {
+    throw nameClashError(resourceType, resolvedName);
+  }
+  const managedName = findManagedNameById(stateManager, resourceType, id);
+  if (!update && managedName !== void 0 && !namesEqual(managedName, resolvedName)) {
+    throw new Error(
+      `This ${resourceType} (id ${id}) is already managed by this project under the name "${managedName}", but is now named "${resolvedName}" on the platform.`
+    );
+  }
+  return managedName;
+}
 function writeResourceFiles(rootDir, resourceType, resource, apiResponse) {
   const safeName = sanitizeFileName(resource.name);
+  const target = resource;
   if (resourceType === "workflow") {
     const workflow = apiResponse;
     const workflowResource = resource;
     if (workflow.yaml_config) {
       const defFileName = `${safeName}.yaml`;
-      const defPath = path6.join(rootDir, "workflows", defFileName);
+      const defPath = path16.join(rootDir, "workflows", defFileName);
       ensureDirectoryExists(defPath);
-      fs6.writeFileSync(defPath, workflow.yaml_config, "utf8");
+      fs11.writeFileSync(defPath, workflow.yaml_config, "utf8");
       logger.info(`   \u{1F4CB} Saved workflow definition: workflows/${defFileName}`);
       workflowResource.definition = `workflows/${defFileName}`;
+    } else {
+      delete target.definition;
     }
-    const configPath = path6.join(rootDir, "configs", "workflows", `${safeName}.yaml`);
+    const configPath = path16.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");
+    const yamlContent2 = yaml6.stringify(workflowResource, { lineWidth: 120 });
+    fs11.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 pluralType = pluralTypeOf(resourceType);
+  const resourceDir = path16.join(rootDir, "configs", "imported-resources", pluralType);
+  const resourceFilePath = path16.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`);
+      const promptPath = path16.join(rootDir, "system_prompts", `${promptFileName}.prompt.md`);
       ensureDirectoryExists(promptPath);
-      fs6.writeFileSync(promptPath, assistant.system_prompt, "utf8");
+      fs11.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 {
+      delete target.prompt;
     }
   } 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);
+      const skillPath = path16.join(rootDir, "skills", skillFileName);
       ensureDirectoryExists(skillPath);
-      fs6.writeFileSync(skillPath, skill.content, "utf8");
+      fs11.writeFileSync(skillPath, skill.content, "utf8");
       logger.info(`   \u{1F9E0} Saved skill content: skills/${skillFileName}`);
       skillResource.file = `skills/${skillFileName}`;
+    } else {
+      delete target.file;
     }
   }
   ensureDirectoryExists(resourceFilePath);
-  const yamlContent = yaml5.stringify(resource, { lineWidth: 120 });
-  fs6.writeFileSync(resourceFilePath, yamlContent, "utf8");
+  const yamlContent = yaml6.stringify(resource, { lineWidth: 120 });
+  fs11.writeFileSync(resourceFilePath, yamlContent, "utf8");
   logger.info(`   \u{1F4C4} Saved resource config: ${relativeResourcePath}`);
   return relativeResourcePath;
 }
+function planCompanionWrite(rootDir, target, key, configuredValue, content, defaultPath, label) {
+  const configuredPath = typeof configuredValue === "string" ? configuredValue : void 0;
+  if (!content) {
+    if (configuredPath === void 0) {
+      delete target[key];
+    } else {
+      target[key] = configuredPath;
+    }
+    return void 0;
+  }
+  const relPath = configuredPath ?? defaultPath;
+  target[key] = relPath;
+  return { absPath: path16.join(rootDir, relPath), content, log: `   ${label}: ${relPath}` };
+}
+var IN_LIST_ITEM_INDENT = 2;
+function itemCarriesAnchorAliasOrMergeKey(node) {
+  if (node.anchor !== void 0) {
+    return true;
+  }
+  return node.items.some((pair) => {
+    const key = pair.key;
+    const keyValue = yaml6.isScalar(key) ? key.value : key;
+    if (keyValue === "<<") {
+      return true;
+    }
+    const value = pair.value;
+    if (yaml6.isAlias(value)) {
+      return true;
+    }
+    return yaml6.isNode(value) && value.anchor !== void 0;
+  });
+}
+function spliceResourceIntoList(filePath, relativeResourcePath, resource, existingName) {
+  const source = fs11.readFileSync(filePath, "utf8");
+  const doc = yaml6.parseDocument(source);
+  const refusal = (reason) => new Error(
+    `Cannot safely update "${existingName}" inside ${relativeResourcePath}: ${reason}. Update ${relativeResourcePath} manually.`
+  );
+  if (!yaml6.isSeq(doc.contents) || doc.contents.flow) {
+    throw refusal("the file is not a block-style YAML sequence");
+  }
+  const node = doc.contents.items.find((item) => {
+    if (!yaml6.isMap(item)) {
+      return false;
+    }
+    const itemName = item.get("name");
+    return typeof itemName === "string" && namesEqual(itemName, existingName);
+  });
+  if (!node?.range) {
+    throw refusal("its entry could not be located as a block mapping in the sequence");
+  }
+  if (node.flow) {
+    throw refusal("its entry uses flow style ({ ... })");
+  }
+  if (itemCarriesAnchorAliasOrMergeKey(node)) {
+    throw refusal("its entry uses a YAML anchor, alias or merge key");
+  }
+  const [start, valueEnd] = node.range;
+  const indent = start - (source.lastIndexOf("\n", start - 1) + 1);
+  if (indent !== IN_LIST_ITEM_INDENT) {
+    throw refusal(`its entry is indented by ${indent} spaces instead of ${IN_LIST_ITEM_INDENT}`);
+  }
+  const rendered = yaml6.stringify(resource, { lineWidth: 120 }).trimEnd();
+  const replacement = rendered.split("\n").map((line, index) => index === 0 || !line ? line : `${" ".repeat(IN_LIST_ITEM_INDENT)}${line}`).join("\n");
+  const tail = source.slice(valueEnd);
+  const separator = tail.startsWith("\n") ? "" : "\n";
+  return source.slice(0, start) + replacement + separator + tail;
+}
+function updateResourceFiles(rootDir, resourceType, resource, apiResponse, existing) {
+  const filePath = existing.file;
+  if (!filePath) {
+    throw new Error("updateResourceFiles requires an existing resource backed by a file");
+  }
+  const existingResource = existing.resource;
+  const target = resource;
+  const safeName = sanitizeFileName(resource.name);
+  for (const [key, value] of Object.entries(existingResource)) {
+    if (key === "skill_ids" || key in target) {
+      continue;
+    }
+    target[key] = value;
+  }
+  let companion;
+  if (resourceType === "assistant") {
+    const assistant = apiResponse;
+    companion = planCompanionWrite(
+      rootDir,
+      target,
+      "prompt",
+      existingResource.prompt,
+      assistant.system_prompt,
+      `system_prompts/${assistant.slug || safeName}.prompt.md`,
+      "\u{1F4DD} Updated prompt"
+    );
+  } else if (resourceType === "skill") {
+    const skill = apiResponse;
+    companion = planCompanionWrite(
+      rootDir,
+      target,
+      "file",
+      existingResource.file,
+      skill.content,
+      `skills/${safeName}.skill.md`,
+      "\u{1F9E0} Updated skill content"
+    );
+  } else if (resourceType === "workflow") {
+    const workflow = apiResponse;
+    companion = planCompanionWrite(
+      rootDir,
+      target,
+      "definition",
+      existingResource.definition,
+      workflow.yaml_config,
+      `workflows/${safeName}.yaml`,
+      "\u{1F4CB} Updated workflow definition"
+    );
+  }
+  const relativeResourcePath = path16.relative(rootDir, filePath);
+  const newResourceFileContent = existing.inList ? spliceResourceIntoList(filePath, relativeResourcePath, resource, String(existingResource.name)) : yaml6.stringify(resource, { lineWidth: 120 });
+  if (companion) {
+    ensureDirectoryExists(companion.absPath);
+    fs11.writeFileSync(companion.absPath, companion.content, "utf8");
+    logger.info(companion.log);
+  }
+  fs11.writeFileSync(filePath, newResourceFileContent, "utf8");
+  logger.info(`   \u{1F4C4} Updated resource config: ${relativeResourcePath}`);
+  return relativeResourcePath;
+}
+function deleteStateEntry(stateManager, resourceType, name) {
+  switch (resourceType) {
+    case "assistant": {
+      stateManager.deleteAssistantState(name);
+      break;
+    }
+    case "datasource": {
+      stateManager.deleteDatasourceState(name);
+      break;
+    }
+    case "workflow": {
+      stateManager.deleteWorkflowState(name);
+      break;
+    }
+    case "skill": {
+      stateManager.deleteSkillState(name);
+      break;
+    }
+  }
+}
 function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relativeResourcePath) {
-  const configPath = path6.join(rootDir, codemieConfigPath);
-  if (!fs6.existsSync(configPath)) {
+  const configPath = path16.join(rootDir, codemieConfigPath);
+  if (!fs11.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";
+  const content = fs11.readFileSync(configPath, "utf8");
+  const doc = yaml6.parseDocument(content);
+  const pluralType = pluralTypeOf(resourceType);
   let resourcesNode = doc.get("resources");
   if (!resourcesNode) {
     resourcesNode = doc.createNode({});
@@ -4226,7 +4490,7 @@ function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relati
   }
   const importDirective = { $import: relativeResourcePath };
   const existingImports = typeArray.items.filter((item) => {
-    if (yaml5.isMap(item)) {
+    if (yaml6.isMap(item)) {
       const importValue = item.get("$import");
       return importValue === relativeResourcePath;
     }
@@ -4238,16 +4502,16 @@ function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relati
   }
   const newNode = doc.createNode(importDirective);
   typeArray.add(newNode);
-  fs6.writeFileSync(configPath, doc.toString(), "utf8");
+  fs11.writeFileSync(configPath, doc.toString(), "utf8");
   logger.info(`   \u2705 Added $import to ${codemieConfigPath} \u2192 resources.${pluralType}`);
 }
 function addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill) {
-  const configPath = path6.join(rootDir, codemieConfigPath);
-  if (!fs6.existsSync(configPath)) {
+  const configPath = path16.join(rootDir, codemieConfigPath);
+  if (!fs11.existsSync(configPath)) {
     throw new Error(`Configuration file not found: ${configPath}`);
   }
-  const content = fs6.readFileSync(configPath, "utf8");
-  const doc = yaml5.parseDocument(content);
+  const content = fs11.readFileSync(configPath, "utf8");
+  const doc = yaml6.parseDocument(content);
   let importedNode = doc.get("imported");
   if (!importedNode) {
     importedNode = doc.createNode({ assistants: [], datasources: [], skills: [], integrations: [] });
@@ -4259,7 +4523,7 @@ function addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill) {
     doc.setIn(["imported", "skills"], skillsArray);
   }
   const existingSkill = skillsArray.items.find((item) => {
-    if (!yaml5.isMap(item)) {
+    if (!yaml6.isMap(item)) {
       return false;
     }
     const existingName = item.get("name");
@@ -4276,9 +4540,47 @@ function addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill) {
     return;
   }
   skillsArray.add(doc.createNode({ name: skill.name, id: skill.id }));
-  fs6.writeFileSync(configPath, doc.toString(), "utf8");
+  fs11.writeFileSync(configPath, doc.toString(), "utf8");
   logger.info(`   \u2705 Added skill to ${codemieConfigPath} \u2192 imported.skills`);
 }
+function updateImportedSkillInCodemieYaml(rootDir, codemieConfigPath, skill) {
+  const configPath = path16.join(rootDir, codemieConfigPath);
+  if (!fs11.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const content = fs11.readFileSync(configPath, "utf8");
+  const doc = yaml6.parseDocument(content);
+  const skillsArray = doc.getIn(["imported", "skills"]);
+  if (!skillsArray) {
+    return false;
+  }
+  const items = skillsArray.items.filter((item) => yaml6.isMap(item));
+  const entryById = items.find((item) => {
+    const existingId = item.get("id");
+    return typeof existingId === "string" && existingId === skill.id;
+  });
+  const entry = entryById ?? items.find((item) => {
+    const existingName = item.get("name");
+    return typeof existingName === "string" && namesEqual(existingName, skill.name);
+  });
+  if (!entry) {
+    return false;
+  }
+  entry.set("name", skill.name);
+  entry.set("id", skill.id);
+  fs11.writeFileSync(configPath, doc.toString(), "utf8");
+  return true;
+}
+function upsertImportedSkill(rootDir, codemieConfigPath, skill, update) {
+  if (update) {
+    if (updateImportedSkillInCodemieYaml(rootDir, codemieConfigPath, skill)) {
+      logger.info(`   \u267B\uFE0F  Refreshed imported.skills entry for external skill "${skill.name}"`);
+      return;
+    }
+    logger.info(`   No existing skill found in the configuration \u2014 importing as new`);
+  }
+  addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill);
+}
 function ensureExternalSkillDoesNotConflictWithManagedSkill(config, skillName) {
   const managedSkill = config.resources.skills?.find((skill) => namesEqual(skill.name, skillName));
   if (!managedSkill) {
@@ -4331,7 +4633,7 @@ function buildIntegrationAliasMap(config) {
   return map;
 }
 async function importResource(options) {
-  const { appConfig, resourceType, slug } = options;
+  const { appConfig, resourceType, slug, update = false } = options;
   if (!VALID_RESOURCE_TYPES.includes(resourceType)) {
     throw new Error(`Invalid resource type: "${resourceType}". Must be one of: ${VALID_RESOURCE_TYPES.join(", ")}`);
   }
@@ -4339,10 +4641,8 @@ async function importResource(options) {
   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.`
-    );
+  if (!update && checkResourceExists2(config, resourceType, slug)) {
+    throw nameClashError(resourceType, slug);
   }
   logger.info(`
 \u{1F50D} Importing ${resourceType}: "${slug}"
@@ -4352,11 +4652,21 @@ async function importResource(options) {
   const integrationAliasMap = buildIntegrationAliasMap(config);
   let resource;
   let apiResponse;
+  let managedName;
   switch (resourceType) {
     case "assistant": {
       logger.info(`   Searching for assistant "${slug}"...`);
       const assistant = await findAssistant(client, slug);
       logger.info(`   \u2713 Found: ${assistant.name} (${assistant.id})`);
+      managedName = assertResolvedNameIsFree(
+        config,
+        stateManager,
+        resourceType,
+        slug,
+        assistant.name,
+        assistant.id,
+        update
+      );
       apiResponse = assistant;
       resource = assistantResponseToResource(assistant);
       if (integrationAliasMap.size > 0) {
@@ -4390,7 +4700,7 @@ async function importResource(options) {
           logger.info(`     \u2713 Resolved skill ${skillId.slice(0, 8)}... \u2192 "${skill.name}"`);
           if (!isProjectOwnedSkill(skill, config.project.name)) {
             ensureExternalSkillDoesNotConflictWithManagedSkill(config, skill.name);
-            addImportedSkillToCodemieYaml(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id });
+            upsertImportedSkill(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id }, update);
           }
         }
         if (skillNames.length > 0) {
@@ -4403,6 +4713,15 @@ async function importResource(options) {
       logger.info(`   Searching for datasource "${slug}"...`);
       const datasource = await findDatasource(client, slug);
       logger.info(`   \u2713 Found: ${datasource.name} (${datasource.id})`);
+      managedName = assertResolvedNameIsFree(
+        config,
+        stateManager,
+        resourceType,
+        slug,
+        datasource.name,
+        datasource.id,
+        update
+      );
       apiResponse = datasource;
       const settingId = datasource.setting_id || "";
       const integrationAlias = integrationAliasMap.get(settingId);
@@ -4413,11 +4732,15 @@ async function importResource(options) {
       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.`
-        );
-      }
+      managedName = assertResolvedNameIsFree(
+        config,
+        stateManager,
+        resourceType,
+        slug,
+        workflow.name,
+        workflow.id,
+        update
+      );
       apiResponse = workflow;
       resource = workflowResponseToResource(workflow);
       break;
@@ -4426,24 +4749,44 @@ async function importResource(options) {
       logger.info(`   Searching for skill "${slug}"...`);
       const skill = await findSkill(client, slug);
       logger.info(`   \u2713 Found: ${skill.name} (${skill.id})`);
-      if (skill.name !== slug && checkResourceExists2(config, resourceType, skill.name)) {
-        throw new Error(
-          `A ${resourceType} named "${skill.name}" already exists in the configuration. Remove it first or use a different name.`
-        );
-      }
+      managedName = assertResolvedNameIsFree(config, stateManager, resourceType, slug, skill.name, skill.id, update);
       if (isProjectOwnedSkill(skill, config.project.name)) {
         logger.info(`   Project-owned skill \u2014 importing into resources.skills`);
         apiResponse = skill;
         resource = skillResponseToResource(skill);
         break;
       }
-      addImportedSkillToCodemieYaml(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id });
+      upsertImportedSkill(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id }, update);
       logger.info(`
 \u2705 Successfully imported external skill "${skill.name}" into imported.skills
 `);
       return;
     }
   }
+  if (update) {
+    const pluralType = pluralTypeOf(resourceType);
+    const lookupName = managedName ?? resource.name;
+    const existing = findResourceDefinition(rootDir, appConfig.codemieConfig, pluralType, lookupName);
+    if (existing) {
+      if (existing.file === null) {
+        throw new Error(
+          `Cannot update "${resource.name}": it is not defined in a file referenced by codemie.yaml. Update it manually.`
+        );
+      }
+      logger.info(`   \u267B\uFE0F  Updating existing ${resourceType} config in place...`);
+      updateResourceFiles(rootDir, resourceType, resource, apiResponse, existing);
+      if (managedName !== void 0 && !namesEqual(managedName, resource.name)) {
+        logger.info(`   \u{1F3F7}\uFE0F  Renamed from "${managedName}" to "${resource.name}" \u2014 updating state.json`);
+        deleteStateEntry(stateManager, resourceType, managedName);
+      }
+      updateState(stateManager, resourceType, resource, apiResponse);
+      logger.info(`
+\u2705 Successfully imported ${resourceType} "${resource.name}"
+`);
+      return;
+    }
+    logger.info(`   No existing ${resourceType} found in the configuration \u2014 importing as new`);
+  }
   const relativeResourcePath = writeResourceFiles(rootDir, resourceType, resource, apiResponse);
   addImportToCodemieYaml(rootDir, appConfig.codemieConfig, resourceType, relativeResourcePath);
   updateState(stateManager, resourceType, resource, apiResponse);
@@ -4464,7 +4807,7 @@ async function main4(options) {
 }
 init_logger();
 function fileExists(filePath) {
-  return fs6.existsSync(filePath);
+  return fs11.existsSync(filePath);
 }
 function generateEnvTemplate() {
   return `# Codemie API Configuration
@@ -4543,14 +4886,14 @@ function compareConfigWithDefaults(userConfig) {
 }
 async function saveConfigFile(config, defaultFilename = "config.json") {
   const configFilename = await promptUser(`Enter config file path`, defaultFilename);
-  const configPath = path6.resolve(process.cwd(), configFilename);
+  const configPath = path16.resolve(process.cwd(), configFilename);
   if (fileExists(configPath)) {
     const shouldOverwrite = await confirmOverwrite(configFilename);
     if (!shouldOverwrite) {
       throw new Error(`Cancelled: Configuration file not saved.`);
     }
   }
-  fs6.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  fs11.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
   return configFilename;
 }
 function suggestConfigUsage(configFileName) {
@@ -4569,8 +4912,8 @@ async function initProject(options) {
   logger.info("\u{1F680} Initialize Codemie IaC Project\n\n");
   try {
     const { appConfig } = options;
-    const envPath = path6.resolve(appConfig.rootDir, ".env");
-    const configPath = path6.resolve(appConfig.rootDir, appConfig.codemieConfig);
+    const envPath = path16.resolve(appConfig.rootDir, ".env");
+    const configPath = path16.resolve(appConfig.rootDir, appConfig.codemieConfig);
     logger.info("This wizard will create the following files:");
     logger.info(`  \u{1F4C4} .env - Environment variables with API credentials`);
     logger.info(`  \u{1F4C4} ${appConfig.codemieConfig} - Codemie IaC configuration
@@ -4623,7 +4966,7 @@ async function initProject(options) {
     logger.info("\n\u{1F4C1} Creating configuration files...\n");
     if (shouldCreateEnv) {
       const envContent = generateEnvTemplate();
-      fs6.writeFileSync(envPath, envContent, "utf-8");
+      fs11.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!
@@ -4631,7 +4974,7 @@ async function initProject(options) {
     }
     if (shouldCreateConfig) {
       const configContent = generateMinimalCodemieYaml(projectName, projectDescription);
-      fs6.writeFileSync(configPath, configContent, "utf-8");
+      fs11.writeFileSync(configPath, configContent, "utf-8");
       logger.info(`\u2713 Created ${appConfig.codemieConfig}`);
       logger.info(`  See examples/ directory for detailed configuration examples
 
@@ -4665,6 +5008,7 @@ async function main5(options) {
 // src/cli/index.ts
 init_commandSpinner();
 init_logger();
+init_logger();
 
 // src/lib/previewUtils.ts
 init_checksumUtils();
@@ -4895,11 +5239,11 @@ async function previewWorkflows(workflows, stateManager, client, rootDir = proce
   const projectClause = project ? ` in project ${project}` : "";
   const staleDetails = `ID from state not found; will adopt a same-name workflow${projectClause} if one exists, otherwise create`;
   for (const workflow of workflows) {
-    const yamlPath = path6.join(rootDir, workflow.definition);
-    if (!fs6.existsSync(yamlPath)) {
+    const yamlPath = path16.join(rootDir, workflow.definition);
+    if (!fs11.existsSync(yamlPath)) {
       throw new Error(`Workflow definition file not found: ${workflow.definition}`);
     }
-    const yamlConfig = fs6.readFileSync(yamlPath, "utf8");
+    const yamlConfig = fs11.readFileSync(yamlPath, "utf8");
     const change = await previewResource(
       workflow,
       "workflow",
@@ -5087,10 +5431,10 @@ var DependencyValidator = class {
     const errors = [];
     const visited = /* @__PURE__ */ new Set();
     const recursionStack = /* @__PURE__ */ new Set();
-    const dfs = (name, path16) => {
+    const dfs = (name, path17) => {
       if (recursionStack.has(name)) {
-        const cycleStart = path16.indexOf(name);
-        const cycle = [...path16.slice(cycleStart), name];
+        const cycleStart = path17.indexOf(name);
+        const cycle = [...path17.slice(cycleStart), name];
         errors.push(`Cyclic dependency detected: ${cycle.join(" \u2192 ")}`);
         return true;
       }
@@ -5099,14 +5443,14 @@ var DependencyValidator = class {
       }
       visited.add(name);
       recursionStack.add(name);
-      path16.push(name);
+      path17.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, [...path16])) {
+        if (dfs(subRef, [...path17])) {
           return true;
         }
       }
@@ -5165,7 +5509,7 @@ var DependencyValidator = class {
     }
     for (const workflow of workflows) {
       try {
-        const workflowYaml = yaml5.parse(workflow.definition);
+        const workflowYaml = yaml6.parse(workflow.definition);
         if (!workflowYaml.assistants) {
           continue;
         }
@@ -5305,12 +5649,12 @@ 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 (!fs6.existsSync(workflowPath)) {
+      const workflowPath = path16.resolve(workflow.definition);
+      if (!fs11.existsSync(workflowPath)) {
         errors.push(`Workflow definition file not found: ${workflow.definition}`);
         return { ...workflow, definition: "" };
       }
-      const definition = fs6.readFileSync(workflowPath, "utf8");
+      const definition = fs11.readFileSync(workflowPath, "utf8");
       return { ...workflow, definition };
     });
     const workflowErrors = DependencyValidator.validateWorkflowAssistantReferences(
@@ -5374,55 +5718,62 @@ async function main7(options) {
 
 // src/cli/index.ts
 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();
+program.command("init").description("Initialize a new Codemie IaC project").option("-d, --root-dir <path>", "Project root directory (containing codemie.yaml)").action((options) => {
+  const rootDir = options.rootDir ? path16__default.resolve(options.rootDir) : void 0;
+  const appConfig = loadAppConfig(void 0, rootDir ?? process.cwd());
   void main5({ appConfig });
 });
-program.command("deploy").description("Deploy resources to Codemie platform").option("-p, --prune", "Delete orphaned resources").option("--skip-datasources", "Skip the datasource stage entirely (no create/update/delete, no indexing)").option("-c, --config <path>", "Configuration file").action(async (options) => {
-  const configPath = options.config ? path6__default.resolve(options.config) : void 0;
-  const appConfig = loadAppConfig(configPath);
+program.command("deploy").description("Deploy resources to Codemie platform").option("-p, --prune", "Delete orphaned resources").option("--skip-datasources", "Skip the datasource stage entirely (no create/update/delete, no indexing)").option("-d, --root-dir <path>", "Project root directory (containing codemie.yaml)").option("-c, --config <path>", "Configuration file").action(async (options) => {
+  const configPath = options.config ? path16__default.resolve(options.config) : void 0;
+  const rootDir = options.rootDir ? path16__default.resolve(options.rootDir) : void 0;
+  const appConfig = loadAppConfig(configPath, rootDir);
   await runCommandWithSpinner(
     "Deploying Codemie resources",
     () => main2({ appConfig, prune: options.prune, skipDatasources: options.skipDatasources })
   );
 });
-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);
+program.command("backup").description("Backup all resources from Codemie platform").option("-d, --root-dir <path>", "Project root directory (containing codemie.yaml)").option("-c, --config <path>", "Configuration file").action(async (options) => {
+  const configPath = options.config ? path16__default.resolve(options.config) : void 0;
+  const rootDir = options.rootDir ? path16__default.resolve(options.rootDir) : void 0;
+  const appConfig = loadAppConfig(configPath, rootDir);
   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(async (options) => {
-  const configPath = options.config ? path6__default.resolve(options.config) : void 0;
-  const appConfig = loadAppConfig(configPath);
+program.command("destroy").description("Destroy all IaC-managed resources").option("-f, --force", "Skip confirmation prompt").option("-d, --root-dir <path>", "Project root directory (containing codemie.yaml)").option("-c, --config <path>", "Configuration file").action(async (options) => {
+  const configPath = options.config ? path16__default.resolve(options.config) : void 0;
+  const rootDir = options.rootDir ? path16__default.resolve(options.rootDir) : void 0;
+  const appConfig = loadAppConfig(configPath, rootDir);
   await runCommandWithSpinner("Destroying Codemie resources", () => main3({ appConfig, force: options.force }));
 });
-program.command("preview").description("Preview changes without applying them").option("--skip-datasources", "Exclude datasources from preview (mirrors deploy --skip-datasources)").option("-c, --config <path>", "Configuration file").action(async (options) => {
-  const appConfigPath = options.config ? path6__default.resolve(options.config) : void 0;
-  const appConfig = loadAppConfig(appConfigPath);
+program.command("preview").description("Preview changes without applying them").option("--skip-datasources", "Exclude datasources from preview (mirrors deploy --skip-datasources)").option("-d, --root-dir <path>", "Project root directory (containing codemie.yaml)").option("-c, --config <path>", "Configuration file").action(async (options) => {
+  const appConfigPath = options.config ? path16__default.resolve(options.config) : void 0;
+  const rootDir = options.rootDir ? path16__default.resolve(options.rootDir) : void 0;
+  const appConfig = loadAppConfig(appConfigPath, rootDir);
   await runCommandWithSpinner(
     "Generating Codemie preview",
     () => main6({ appConfig, skipDatasources: options.skipDatasources })
   );
 });
-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);
+program.command("validate").description("Validate configuration").option("-a, --check-api", "Check for API conflicts").option("-d, --root-dir <path>", "Project root directory (containing codemie.yaml)").option("-c, --config <path>", "Configuration file").action(async (options) => {
+  const configPath = options.config ? path16__default.resolve(options.config) : void 0;
+  const rootDir = options.rootDir ? path16__default.resolve(options.rootDir) : void 0;
+  const appConfig = loadAppConfig(configPath, rootDir);
   await runCommandWithSpinner(
     "Validating Codemie configuration",
     () => main7({ appConfig, checkApi: options.checkApi })
   );
 });
-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)) {
+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 (a platform UUID also works for assistant and workflow)").option("-d, --root-dir <path>", "Project root directory (containing codemie.yaml)").option("-c, --config <path>", "Configuration file").option("-u, --update", "Refresh an already-managed resource in place instead of failing on a conflict").action(async (type, slug, options) => {
+  if (!VALID_RESOURCE_TYPES.includes(type)) {
+    logger.error(`\u274C Invalid resource type: "${type}". Must be one of: ${VALID_RESOURCE_TYPES.join(", ")}`);
     process.exitCode = 1;
     return;
   }
-  const configPath = options.config ? path6__default.resolve(options.config) : void 0;
-  const appConfig = loadAppConfig(configPath);
+  const configPath = options.config ? path16__default.resolve(options.config) : void 0;
+  const rootDir = options.rootDir ? path16__default.resolve(options.rootDir) : void 0;
+  const appConfig = loadAppConfig(configPath, rootDir);
   await runCommandWithSpinner(
     `Importing ${type}`,
-    () => main4({ appConfig, resourceType: type, slug })
+    () => main4({ appConfig, resourceType: type, slug, update: options.update })
   );
 });
 program.parse();