@codemieai/cdk 0.1.543 → 0.1.544

package/dist/index.js

@@ -1,6 +1,6 @@
 import ora from 'ora';
 import * as crypto from 'crypto';
-import { CodeMieClient, DataSourceType } from 'codemie-sdk';
+import { CodeMieClient, DataSourceType, SkillVisibility } from 'codemie-sdk';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml6 from 'yaml';
@@ -689,11 +689,23 @@ var init_fileUtils = __esm({
   }
 });
 
+// src/lib/skillUtils.ts
+function isProjectOwnedSkill(skill, projectName) {
+  return skill.project.trim().toLowerCase() === projectName.trim().toLowerCase();
+}
+var init_skillUtils = __esm({
+  "src/lib/skillUtils.ts"() {
+  }
+});
+
 // src/lib/backupTransformers.ts
 var backupTransformers_exports = {};
 __export(backupTransformers_exports, {
+  collectReferencedSkillIds: () => collectReferencedSkillIds,
+  partitionSkillsForBackupYaml: () => partitionSkillsForBackupYaml,
   prepareAssistantForYaml: () => prepareAssistantForYaml,
   prepareDatasourceForYaml: () => prepareDatasourceForYaml,
+  prepareImportedSkillForYaml: () => prepareImportedSkillForYaml,
   prepareSkillForYaml: () => prepareSkillForYaml,
   prepareWorkflowForYaml: () => prepareWorkflowForYaml,
   transformMcpServer: () => transformMcpServer,
@@ -850,6 +862,36 @@ function prepareWorkflowForYaml(workflow, state, assistants, backupDir) {
   };
   return resource;
 }
+function collectReferencedSkillIds(assistants) {
+  const referencedSkillIds = /* @__PURE__ */ new Set();
+  for (const assistant of assistants) {
+    const assistantData = assistant;
+    for (const skillId of assistantData.skill_ids || []) {
+      referencedSkillIds.add(skillId);
+    }
+  }
+  return referencedSkillIds;
+}
+function partitionSkillsForBackupYaml(skills, projectName, referencedSkillIds) {
+  const ownedSkills = [];
+  const importedSkills = [];
+  for (const skill of skills) {
+    if (isProjectOwnedSkill(skill, projectName)) {
+      ownedSkills.push(skill);
+      continue;
+    }
+    if (referencedSkillIds.has(skill.id)) {
+      importedSkills.push(skill);
+    }
+  }
+  return { ownedSkills, importedSkills };
+}
+function prepareImportedSkillForYaml(skill) {
+  return {
+    name: skill.name,
+    id: skill.id
+  };
+}
 function prepareSkillForYaml(skill, state) {
   const resource = skillResponseToResource(skill);
   if (!state.resources.skills) {
@@ -870,9 +912,17 @@ var init_backupTransformers = __esm({
     init_converters();
     init_fileUtils();
     init_logger();
+    init_skillUtils();
     init_typeGuards();
   }
 });
+
+// src/lib/nameUtils.ts
+function namesEqual(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+
+// src/lib/codemieConfigLoader.ts
 var CodemieConfigLoader = class {
   appConfig;
   constructor(appConfig) {
@@ -967,6 +1017,14 @@ var CodemieConfigLoader = class {
         }
       }
     }
+    for (const skill of config.imported?.skills || []) {
+      if (!skill.name) {
+        errors.push("Imported skill entry is missing required field: name");
+      }
+      if (!skill.id) {
+        errors.push(`Imported skill "${skill.name || "<unknown>"}" is missing required field: id`);
+      }
+    }
     return {
       valid: errors.length === 0,
       errors
@@ -1181,6 +1239,7 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
    * - imported.integrations (array): searches by 'alias' field
    * - imported.assistants (array): searches by 'name' field
    * - imported.datasources (array): searches by 'name' field
+   * - imported.skills (array): searches by 'name' field
    */
   resolveReference(config, ref, context) {
     const parts = ref.split(".");
@@ -1204,9 +1263,16 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
       if (Array.isArray(current) && hasMorePathSegments) {
         const nextPathSegment = parts[i + 1];
         const searchField = part === "integrations" ? "alias" : "name";
-        const foundItem = current.find(
-          (item) => typeof item === "object" && item !== null && item[searchField] === nextPathSegment
-        );
+        const foundItem = current.find((item) => {
+          if (typeof item !== "object" || item === null) {
+            return false;
+          }
+          const fieldValue = item[searchField];
+          if (typeof fieldValue !== "string") {
+            return false;
+          }
+          return searchField === "alias" ? fieldValue === nextPathSegment : namesEqual(fieldValue, nextPathSegment);
+        });
         if (!foundItem) {
           throw new Error(
             `Reference path "${ref}" not found: no item with ${searchField}="${nextPathSegment}" in "${pathParts.join(".")}". Referenced in ${context}.`
@@ -1612,12 +1678,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));
+    const configSkillNames = new Set((config.resources.skills || []).map(({ name }) => name.toLowerCase()));
     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)),
-      skills: managedResources.skills.filter((name) => !configSkillNames.has(name))
+      skills: managedResources.skills.filter((name) => !configSkillNames.has(name.toLowerCase()))
     };
   }
   /**
@@ -1886,6 +1952,62 @@ function checkSkillExists(client, name, stateManager) {
   );
 }
 
+// src/lib/resourceResolver.ts
+init_logger();
+function findSkillStateByName(stateManager, skillName) {
+  const exactMatch = stateManager.getSkillState(skillName);
+  if (exactMatch) {
+    return exactMatch;
+  }
+  for (const name of stateManager.getAllManagedResources().skills) {
+    if (namesEqual(name, skillName)) {
+      return stateManager.getSkillState(name);
+    }
+  }
+  return void 0;
+}
+function findConfiguredSkill(config, skillName) {
+  return config.resources.skills?.find((skill) => namesEqual(skill.name, skillName));
+}
+function findImportedSkill(config, skillName) {
+  return config.imported?.skills?.find((skill) => namesEqual(skill.name, skillName));
+}
+function lookupSkillId(skillName, stateManager, config) {
+  const configuredSkill = findConfiguredSkill(config, skillName);
+  const importedSkill = findImportedSkill(config, skillName);
+  if (configuredSkill && importedSkill) {
+    return void 0;
+  }
+  if (importedSkill) {
+    return importedSkill.id;
+  }
+  if (!configuredSkill) {
+    return void 0;
+  }
+  return findSkillStateByName(stateManager, configuredSkill.name)?.id;
+}
+function resolveSkillId(skillName, stateManager, config) {
+  const configuredSkill = findConfiguredSkill(config, skillName);
+  const importedSkill = findImportedSkill(config, skillName);
+  if (configuredSkill && importedSkill) {
+    throw new Error(
+      `Skill "${skillName}" is defined in both resources.skills and imported.skills. Keep project-owned skills in resources.skills or external skills in imported.skills, not both.`
+    );
+  }
+  const skillId = lookupSkillId(skillName, stateManager, config);
+  if (skillId) {
+    const source = importedSkill ? "imported" : "state";
+    logger.info(`    \u2713 Resolved${source === "imported" ? " (imported)" : ""} "${skillName}" \u2192 ${skillId}`);
+    return skillId;
+  }
+  throw new Error(
+    `Skill "${skillName}" cannot be resolved. For project-owned skills, define it in resources.skills and deploy it so state.json contains its ID. For external skills, add name and id to imported.skills.`
+  );
+}
+function resolveSkillIds(skillNames, stateManager, config) {
+  return skillNames.map((name) => resolveSkillId(name, stateManager, config));
+}
+
 // src/deploy.ts
 function sortAssistantsByDependencies(assistants) {
   const sorted = [];
@@ -2029,16 +2151,7 @@ async function deployAssistants(config, client, loader, stateManager) {
       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;
+        resolvedSkillIds = resolveSkillIds(assistant.skills, stateManager, config);
       }
       const assistantWithResolved = {
         ...assistant,
@@ -2158,9 +2271,8 @@ async function deployAssistants(config, client, loader, stateManager) {
         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)}`);
+          logger.error(`     Status: ${String(error.statusCode)}`);
+          logger.error(`     Data: ${JSON.stringify("response" in error ? error.response : void 0, null, 2)}`);
         } else if ("response" in error) {
           const axiosError = error;
           logger.error(`     Status: ${axiosError.response?.status}`);
@@ -2607,6 +2719,13 @@ async function deployResources(options) {
       }
       if (orphaned.skills.length > 0) {
         logger.info(`   \u2022 ${orphaned.skills.length} skill(s)`);
+        const importedSkillNames = new Set(config.imported?.skills?.map((skill) => skill.name.toLowerCase()) || []);
+        const migratedImportedSkills = orphaned.skills.filter((name) => importedSkillNames.has(name.toLowerCase()));
+        if (migratedImportedSkills.length > 0) {
+          logger.info(
+            `     \u26A0\uFE0F  ${migratedImportedSkills.length} skill(s) also exist in imported.skills. Run with --prune to remove stale IaC-managed skill state and delete old managed skill(s) from platform.`
+          );
+        }
       }
       if (process.env.SAMPLE_DEPLOY === "1") {
         logger.info("\n\u{1F50E} SAMPLE_DEPLOY=1 -> Skipping orphan deletion (simulation / partial deploy mode)\n");
@@ -2804,6 +2923,32 @@ var DependencyValidator = class {
     }
     return errors;
   }
+  /**
+   * Validate assistant skill references.
+   * Check that all skill names point to resources.skills or imported.skills entries.
+   */
+  static validateAssistantSkillReferences(assistants, managedSkills, importedSkills) {
+    const errors = [];
+    for (const managedSkill of managedSkills) {
+      const importedSkill = importedSkills.find((skill) => namesEqual(skill.name, managedSkill.name));
+      if (importedSkill) {
+        errors.push(
+          `Skill "${managedSkill.name}" is defined in both resources.skills and imported.skills. Keep project-owned skills in resources.skills or external skills in imported.skills, not both.`
+        );
+      }
+    }
+    const isSkillAvailable = (skillName) => managedSkills.some((skill) => namesEqual(skill.name, skillName)) || importedSkills.some((skill) => namesEqual(skill.name, skillName));
+    for (const assistant of assistants) {
+      for (const skillName of assistant.skills || []) {
+        if (!isSkillAvailable(skillName)) {
+          errors.push(
+            `Assistant "${assistant.name}": Skill reference "${skillName}" not found in resources.skills or imported.skills`
+          );
+        }
+      }
+    }
+    return errors;
+  }
 };
 
 // src/validate.ts
@@ -2887,6 +3032,12 @@ async function validateConfig(options) {
   if (config.resources.assistants && config.resources.assistants.length > 0) {
     const dependencyErrors = DependencyValidator.validateAssistantDependencies(config.resources.assistants);
     errors.push(...dependencyErrors);
+    const skillReferenceErrors = DependencyValidator.validateAssistantSkillReferences(
+      config.resources.assistants,
+      config.resources.skills || [],
+      config.imported?.skills || []
+    );
+    errors.push(...skillReferenceErrors);
   }
   if (config.resources.workflows && config.resources.workflows.length > 0) {
     const workflowsWithContent = config.resources.workflows.map((workflow) => {
@@ -3021,7 +3172,7 @@ async function previewSkills(skills, loader, stateManager, client) {
   }
   return changes;
 }
-async function previewAssistants(assistants, loader, stateManager, client) {
+async function previewAssistants(assistants, loader, stateManager, client, config) {
   const changes = [];
   for (const assistant of assistants) {
     const promptContent = loader.loadPrompt(assistant.prompt);
@@ -3038,17 +3189,16 @@ async function previewAssistants(assistants, loader, stateManager, client) {
       async () => {
         const existingState = stateManager.getAssistantState(assistant.name);
         const configChanged = existingState ? existingState.promptChecksum !== calculateChecksum(promptContent) || existingState.configChecksum !== configChecksum : false;
-        if (configChanged) {
-          return {
-            hasChanged: true,
-            createDetails: `Model: ${assistant.model}`,
-            updateDetails: "Prompt or configuration changed"
-          };
-        }
-        if (existingState?.id && assistant.skills !== void 0) {
-          const desiredSkillIds = resolveDesiredSkillIds(assistant.skills, stateManager);
-          const drifted = await checkSkillAttachmentDrift(client, existingState.id, desiredSkillIds);
-          if (drifted) {
+        if (assistant.skills !== void 0) {
+          const { ids: desiredSkillIds, unresolved } = resolveDesiredSkillIds(assistant.skills, stateManager, config);
+          if (unresolved.length > 0) {
+            return {
+              hasChanged: true,
+              createDetails: `Unresolved skill reference(s): ${unresolved.join(", ")}`,
+              updateDetails: `Unresolved skill reference(s): ${unresolved.join(", ")}`
+            };
+          }
+          if (existingState?.id && await checkSkillAttachmentDrift(client, existingState.id, desiredSkillIds)) {
             return {
               hasChanged: true,
               createDetails: `Model: ${assistant.model}`,
@@ -3056,6 +3206,13 @@ async function previewAssistants(assistants, loader, stateManager, client) {
             };
           }
         }
+        if (configChanged) {
+          return {
+            hasChanged: true,
+            createDetails: `Model: ${assistant.model}`,
+            updateDetails: "Prompt or configuration changed"
+          };
+        }
         return {
           hasChanged: false,
           createDetails: `Model: ${assistant.model}`
@@ -3066,15 +3223,18 @@ async function previewAssistants(assistants, loader, stateManager, client) {
   }
   return changes;
 }
-function resolveDesiredSkillIds(skillNames, stateManager) {
+function resolveDesiredSkillIds(skillNames, stateManager, config) {
   const ids = [];
+  const unresolved = [];
   for (const name of skillNames) {
-    const skillState = stateManager.getSkillState(name);
-    if (skillState) {
-      ids.push(skillState.id);
+    const skillId = lookupSkillId(name, stateManager, config);
+    if (skillId) {
+      ids.push(skillId);
+    } else {
+      unresolved.push(name);
     }
   }
-  return ids;
+  return { ids, unresolved };
 }
 async function checkSkillAttachmentDrift(client, assistantId, desiredSkillIds) {
   try {
@@ -3178,7 +3338,7 @@ async function previewChanges(appConfig, existingClient) {
     changes.push(...skillChanges);
   }
   if (config.resources.assistants) {
-    const assistantChanges = await previewAssistants(config.resources.assistants, loader, stateManager, client);
+    const assistantChanges = await previewAssistants(config.resources.assistants, loader, stateManager, client, config);
     changes.push(...assistantChanges);
   }
   if (config.resources.datasources) {
@@ -3205,6 +3365,10 @@ async function previewChanges(appConfig, existingClient) {
   };
 }
 
+// src/backup.ts
+init_backupTransformers();
+init_skillUtils();
+
 // src/lib/constants.ts
 var PAGINATION = {
   DEFAULT_PAGE_SIZE: 100};
@@ -3464,6 +3628,12 @@ function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPath
   const integrationIdToAlias = /* @__PURE__ */ new Map();
   const integrationArray = [];
   const skillIdToName = new Map(backup.resources.skills.map((skill) => [skill.id, skill.name]));
+  const referencedSkillIds = collectReferencedSkillIds(backup.resources.assistants);
+  const { ownedSkills, importedSkills } = partitionSkillsForBackupYaml(
+    backup.resources.skills,
+    projectName,
+    referencedSkillIds
+  );
   for (const integration of backup.resources.integrations) {
     const credentialType = integration.credential_type || "integration";
     const alias = integration.alias || `${String(credentialType).toLowerCase()}_${integration.id.slice(0, 8)}`;
@@ -3509,6 +3679,7 @@ function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPath
     imported: {
       assistants: [],
       datasources: [],
+      skills: importedSkills.map((skill) => prepareImportedSkillForYaml(skill)),
       integrations: integrationArray
     },
     datasource_defaults: {
@@ -3530,8 +3701,8 @@ function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPath
       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))
+      ...ownedSkills.length > 0 && {
+        skills: ownedSkills.map((skill) => prepareSkillForYaml(skill, backup.state))
       }
     }
   };
@@ -3664,6 +3835,27 @@ async function* streamResources(fetchPage, resourceType) {
     }
   }
 }
+function createFallbackImportedSkillDetail(skill) {
+  return {
+    id: skill.id,
+    name: skill.name,
+    description: "",
+    project: skill.project || "",
+    visibility: SkillVisibility.PUBLIC,
+    created_by: null,
+    categories: [],
+    createdDate: "",
+    updatedDate: null,
+    is_attached: true,
+    assistants_count: 0,
+    user_abilities: [],
+    unique_likes_count: 0,
+    unique_dislikes_count: 0,
+    content: "",
+    toolkits: [],
+    mcp_servers: []
+  };
+}
 async function saveAssistantToBackup(assistant, client, backupData, backupDir) {
   logger.info(`   \u2022 ${assistant.name} (${assistant.id})`);
   const full = await withTimeout(
@@ -3856,16 +4048,24 @@ async function backupIntegrations(client, backupData, projectName) {
   logger.info(`\u2713 Backed up ${projectIntegrations.length + userIntegrations.length} integration(s)
 `);
 }
-async function backupSkills(client, backupData, backupDir, transaction) {
+async function backupSkills(client, backupData, backupDir, transaction, projectName) {
   logger.info("\u{1F9E0} Fetching skills...");
+  const referencedSkillIds = collectReferencedSkillIds(backupData.resources.assistants);
   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 skillsToBackup = allSkills.filter(
+    (skill) => referencedSkillIds.has(skill.id) || !skill.project || isProjectOwnedSkill({ project: skill.project }, projectName)
+  );
+  const skippedExternalSkills = allSkills.length - skillsToBackup.length;
+  logger.info(`   Found ${allSkills.length} skill(s), backing up ${skillsToBackup.length}`);
+  if (skippedExternalSkills > 0) {
+    logger.info(`   \u21B7 Skipping ${skippedExternalSkills} unreferenced external skill(s)`);
+  }
+  transaction.setTotal("skills", skillsToBackup.length);
   const limit = createConcurrentLimiter();
-  for (const skill of allSkills) {
+  for (const skill of skillsToBackup) {
     if (transaction.isCompleted("skills", skill.id)) {
       logger.info(`   \u21B7 Skipping ${skill.name} (already backed up)`);
       continue;
@@ -3874,16 +4074,37 @@ async function backupSkills(client, backupData, backupDir, transaction) {
       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}`
-          );
+          const listedAsProjectOwned = skill.project ? isProjectOwnedSkill({ project: skill.project }, projectName) : false;
+          let full;
+          try {
+            full = await withTimeout(
+              client.skills.get(skill.id),
+              TIMEOUTS_MS.SKILL_FETCH,
+              `Timeout fetching skill ${skill.id}`
+            );
+          } catch (error) {
+            if (listedAsProjectOwned || !referencedSkillIds.has(skill.id)) {
+              throw error;
+            }
+            logger.warn(
+              `     \u26A0\uFE0F  Failed to fetch imported skill details for ${skill.name}. Using list response as fallback: ${error instanceof Error ? error.message : String(error)}`
+            );
+            full = createFallbackImportedSkillDetail(skill);
+          }
+          const fullIsProjectOwned = isProjectOwnedSkill(full, projectName);
+          if (!fullIsProjectOwned && !referencedSkillIds.has(skill.id)) {
+            logger.info(`     \u21B7 Skipping unreferenced external skill ${skill.name} (owner: ${full.project})`);
+            return;
+          }
           backupData.resources.skills.push(full);
-          const fileName = `${sanitizeFileName(skill.name)}.skill.md`;
-          const filePath = path.join(backupDir, "skills", fileName);
-          ensureDirectoryExists(filePath);
-          fs.writeFileSync(filePath, full.content || "", "utf8");
+          if (fullIsProjectOwned) {
+            const fileName = `${sanitizeFileName(skill.name)}.skill.md`;
+            const filePath = path.join(backupDir, "skills", fileName);
+            ensureDirectoryExists(filePath);
+            fs.writeFileSync(filePath, full.content || "", "utf8");
+          } else {
+            logger.info(`     \u21B7 Skipping content file for imported skill ${skill.name} (owner: ${full.project})`);
+          }
         }, `Backup skill ${skill.name}`)
       );
       transaction.markCompleted("skills", skill.id);
@@ -3897,7 +4118,7 @@ async function backupSkills(client, backupData, backupDir, transaction) {
       transaction.markFailed("skills", skill.id, errorDetails.message);
     }
   }
-  logger.info(`\u2713 Backed up ${transaction.getData().resources.skills.completed.length} skill(s)
+  logger.info(`\u2713 Backed up ${backupData.resources.skills.length} skill(s)
 `);
 }
 function getUniqueBackupDir(baseDir, timestamp) {
@@ -3982,11 +4203,11 @@ async function backupResources(options) {
         }
       }
     };
-    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 backupAssistants(client, backupData, tempBackupDir, transaction);
+    await backupSkills(client, backupData, tempBackupDir, transaction, config.project.name);
     const stats = transaction.getData();
     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) {
@@ -4034,6 +4255,7 @@ async function backupResources(options) {
 
 // src/import.ts
 init_converters();
+init_skillUtils();
 init_fileUtils();
 init_logger();
 init_checksumUtils();
@@ -4125,7 +4347,14 @@ Please use a more specific name.`);
 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());
+  if (resources.some((r) => namesEqual(r.name, name))) {
+    return true;
+  }
+  if (resourceType === "skill") {
+    const importedSkills = config.imported?.skills || [];
+    return importedSkills.some((skill) => namesEqual(skill.name, name));
+  }
+  return false;
 }
 function writeResourceFiles(rootDir, resourceType, resource, apiResponse) {
   const safeName = sanitizeFileName(resource.name);
@@ -4216,6 +4445,53 @@ function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relati
   fs.writeFileSync(configPath, doc.toString(), "utf8");
   logger.info(`   \u2705 Added $import to ${codemieConfigPath} \u2192 resources.${pluralType}`);
 }
+function addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill) {
+  const configPath = path.join(rootDir, codemieConfigPath);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const content = fs.readFileSync(configPath, "utf8");
+  const doc = yaml6.parseDocument(content);
+  let importedNode = doc.get("imported");
+  if (!importedNode) {
+    importedNode = doc.createNode({ assistants: [], datasources: [], skills: [], integrations: [] });
+    doc.set("imported", importedNode);
+  }
+  let skillsArray = doc.getIn(["imported", "skills"]);
+  if (!skillsArray) {
+    skillsArray = doc.createNode([]);
+    doc.setIn(["imported", "skills"], skillsArray);
+  }
+  const existingSkill = skillsArray.items.find((item) => {
+    if (!yaml6.isMap(item)) {
+      return false;
+    }
+    const existingName = item.get("name");
+    return typeof existingName === "string" && namesEqual(existingName, skill.name);
+  });
+  if (existingSkill) {
+    const existingId = existingSkill.get("id");
+    if (existingId && existingId !== skill.id) {
+      throw new Error(
+        `Skill "${skill.name}" already exists in imported.skills with a different ID (${existingId}). Remove the existing entry or use the intended skill ID.`
+      );
+    }
+    logger.info(`   \u21B7 Skill "${skill.name}" already exists in imported.skills`);
+    return;
+  }
+  skillsArray.add(doc.createNode({ name: skill.name, id: skill.id }));
+  fs.writeFileSync(configPath, doc.toString(), "utf8");
+  logger.info(`   \u2705 Added skill to ${codemieConfigPath} \u2192 imported.skills`);
+}
+function ensureExternalSkillDoesNotConflictWithManagedSkill(config, skillName) {
+  const managedSkill = config.resources.skills?.find((skill) => namesEqual(skill.name, skillName));
+  if (!managedSkill) {
+    return;
+  }
+  throw new Error(
+    `External skill "${skillName}" is already defined in resources.skills. Keep project-owned skills in resources.skills or external skills in imported.skills, not both.`
+  );
+}
 function updateState(stateManager, resourceType, resource, apiResponse) {
   switch (resourceType) {
     case "assistant": {
@@ -4303,16 +4579,22 @@ async function importResource(options) {
         logger.info(`   Resolving ${assistantData.skill_ids.length} skill ID(s)...`);
         const skillNames = [];
         for (const skillId of assistantData.skill_ids) {
+          let skill;
           try {
-            const skill = await withTimeout(
+            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`);
+            continue;
+          }
+          skillNames.push(skill.name);
+          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 });
           }
         }
         if (skillNames.length > 0) {
@@ -4348,9 +4630,22 @@ async function importResource(options) {
       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;
+      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.`
+        );
+      }
+      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 });
+      logger.info(`
+\u2705 Successfully imported external skill "${skill.name}" into imported.skills
+`);
+      return;
     }
   }
   const relativeResourcePath = writeResourceFiles(rootDir, resourceType, resource, apiResponse);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemieai/cdk",
-  "version": "0.1.543",
+  "version": "0.1.544",
   "type": "module",
   "description": "Infrastructure as Code solution for managing Codemie AI assistants, datasources, and workflows through declarative YAML configuration",
   "main": "./dist/index.js",