@przeprogramowani/10x-cli 0.5.0 → 1.1.0

package/dist/index.mjs

@@ -2271,7 +2271,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "@przeprogramowani/10x-cli",
-  version: "0.5.0",
+  version: "1.1.0",
   description: "Open-source CLI for 10xDevs course content",
   repository: {
     type: "git",
@@ -2324,6 +2324,9 @@ var package_default = {
   }
 };
 
+// node_modules/@clack/prompts/dist/index.mjs
+import { stripVTControlCharacters as T2 } from "node:util";
+
 // node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -2833,6 +2836,21 @@ ${import_picocolors2.default.cyan(m2)}
     }
   } }).prompt();
 };
+var ye = (s = "", n = "") => {
+  const t = `
+${s}
+`.split(`
+`), i = T2(n).length, r2 = Math.max(t.reduce((o, l2) => {
+    const $2 = T2(l2);
+    return $2.length > o ? $2.length : o;
+  }, 0), i) + 2, c2 = t.map((o) => `${import_picocolors2.default.gray(a)}  ${import_picocolors2.default.dim(o)}${" ".repeat(r2 - T2(o).length)}${import_picocolors2.default.gray(a)}`).join(`
+`);
+  process.stdout.write(`${import_picocolors2.default.gray(a)}
+${import_picocolors2.default.green(S2)}  ${import_picocolors2.default.reset(n)} ${import_picocolors2.default.gray(N2.repeat(Math.max(r2 - i - 1, 1)) + re)}
+${c2}
+${import_picocolors2.default.gray(ie + N2.repeat(r2 + 2) + ne)}
+`);
+};
 var ve = (s = "") => {
   process.stdout.write(`${import_picocolors2.default.gray(m2)}  ${import_picocolors2.default.red(s)}
 
@@ -2927,6 +2945,20 @@ function readAuth() {
     return null;
   }
 }
+function writeJsonAtomic(path, data, opts = {}) {
+  const tmp = `${path}.tmp`;
+  rmSync(tmp, { force: true });
+  const body = `${JSON.stringify(data, null, 2)}
+`;
+  const writeOpts = opts.mode !== undefined ? { mode: opts.mode } : undefined;
+  writeFileSync(tmp, body, writeOpts);
+  if (opts.mode !== undefined && process.platform !== "win32") {
+    try {
+      chmodSync(tmp, opts.mode);
+    } catch {}
+  }
+  renameSync(tmp, path);
+}
 function saveAuth(data) {
   const dir = configDir();
   if (!existsSync(dir)) {
@@ -2937,17 +2969,7 @@ function saveAuth(data) {
       chmodSync(dir, 448);
     } catch {}
   }
-  const file = authFilePath();
-  const tmp = `${file}.tmp`;
-  rmSync(tmp, { force: true });
-  writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
-`, { mode: 384 });
-  if (process.platform !== "win32") {
-    try {
-      chmodSync(tmp, 384);
-    } catch {}
-  }
-  renameSync(tmp, file);
+  writeJsonAtomic(authFilePath(), data, { mode: 384 });
 }
 function deleteAuth() {
   const file = authFilePath();
@@ -2967,6 +2989,9 @@ function readToolConfig() {
     const parsed = JSON.parse(raw);
     if (typeof parsed.tool !== "string")
       return null;
+    if (parsed.acknowledgedOrphans !== undefined && (!Array.isArray(parsed.acknowledgedOrphans) || !parsed.acknowledgedOrphans.every((x2) => typeof x2 === "string"))) {
+      delete parsed.acknowledgedOrphans;
+    }
     return parsed;
   } catch {
     return null;
@@ -2977,9 +3002,7 @@ function saveToolConfig(config) {
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true, mode: 448 });
   }
-  const file = toolConfigPath();
-  writeFileSync(file, `${JSON.stringify(config, null, 2)}
-`);
+  writeJsonAtomic(toolConfigPath(), config);
 }
 
 // src/lib/api-client.ts
@@ -3917,170 +3940,281 @@ function parseModuleRef(raw) {
   return module;
 }
 
+// src/lib/tool-detect.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/lib/manifest.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+var MANIFEST_FILENAME = ".10x-cli-manifest.json";
+var CLI_PACKAGE_NAME = "@przeprogramowani/10x-cli";
+var MANIFEST_VERSION = 2;
+function readManifest(dir) {
+  const manifestPath = join3(dir, MANIFEST_FILENAME);
+  if (!existsSync3(manifestPath))
+    return null;
+  let raw;
+  try {
+    raw = readFileSync2(manifestPath, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isManifest(parsed))
+    return null;
+  return parsed;
+}
+function writeManifest(dir, manifest) {
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  const manifestPath = join3(dir, MANIFEST_FILENAME);
+  mkdirSync3(dirname2(manifestPath), { recursive: true });
+  writeFileSync2(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function isManifest(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const v2 = value;
+  if (v2["package"] !== CLI_PACKAGE_NAME)
+    return false;
+  if (typeof v2["version"] !== "string")
+    return false;
+  if (v2["manifestVersion"] !== MANIFEST_VERSION)
+    return false;
+  if (typeof v2["lastApplied"] !== "string")
+    return false;
+  if (typeof v2["lessonId"] !== "string")
+    return false;
+  if (typeof v2["course"] !== "string")
+    return false;
+  const files = v2["files"];
+  if (typeof files !== "object" || files === null)
+    return false;
+  const f2 = files;
+  return isSkillsRecord(f2["skills"]) && isStringArray(f2["prompts"]) && isStringArray(f2["configs"]);
+}
+function isSkillsRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  for (const entry of Object.values(value)) {
+    if (typeof entry !== "object" || entry === null)
+      return false;
+    const e2 = entry;
+    if (!isStringArray(e2["files"]))
+      return false;
+  }
+  return true;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
 // src/lib/tool-profile.ts
+var SENTINEL_BEGIN = "<!-- BEGIN @przeprogramowani/10x-cli -->";
+var SENTINEL_END = "<!-- END @przeprogramowani/10x-cli -->";
 var PROFILES = {
   "claude-code": {
     toolId: "claude-code",
     displayName: "Claude Code",
     skillPath: (n) => `.claude/skills/${n}/SKILL.md`,
+    skillDir: (n) => `.claude/skills/${n}`,
     promptPath: (n) => `.claude/prompts/${n}.md`,
     configPath: (n) => `.claude/config-templates/${n}`,
     rulesFile: "CLAUDE.md",
     manifestDir: ".claude",
-    sentinelBegin: "<!-- BEGIN @przeprogramowani/10x-cli -->",
-    sentinelEnd: "<!-- END @przeprogramowani/10x-cli -->"
+    sentinelBegin: SENTINEL_BEGIN,
+    sentinelEnd: SENTINEL_END
   },
   cursor: {
     toolId: "cursor",
     displayName: "Cursor",
     skillPath: (n) => `.cursor/skills/${n}/SKILL.md`,
+    skillDir: (n) => `.cursor/skills/${n}`,
     promptPath: (n) => `.cursor/prompts/${n}.md`,
     configPath: (n) => `.cursor/config-templates/${n}`,
     rulesFile: ".cursor/rules/10x-course.mdc",
     manifestDir: ".cursor",
-    sentinelBegin: "<!-- BEGIN @przeprogramowani/10x-cli -->",
-    sentinelEnd: "<!-- END @przeprogramowani/10x-cli -->"
+    sentinelBegin: SENTINEL_BEGIN,
+    sentinelEnd: SENTINEL_END
   },
   copilot: {
     toolId: "copilot",
     displayName: "GitHub Copilot",
     skillPath: (n) => `.github/skills/${n}/SKILL.md`,
+    skillDir: (n) => `.github/skills/${n}`,
     promptPath: (n) => `.github/prompts/${n}.md`,
     configPath: (n) => `.github/config-templates/${n}`,
     rulesFile: ".github/copilot-instructions.md",
     manifestDir: ".github",
-    sentinelBegin: "<!-- BEGIN @przeprogramowani/10x-cli -->",
-    sentinelEnd: "<!-- END @przeprogramowani/10x-cli -->"
+    sentinelBegin: SENTINEL_BEGIN,
+    sentinelEnd: SENTINEL_END
   },
   codex: {
     toolId: "codex",
     displayName: "Codex CLI",
     skillPath: (n) => `.agents/skills/${n}/SKILL.md`,
+    skillDir: (n) => `.agents/skills/${n}`,
     promptPath: (n) => `.agents/prompts/${n}.md`,
     configPath: (n) => `.agents/config-templates/${n}`,
     rulesFile: "AGENTS.md",
     manifestDir: ".agents",
-    sentinelBegin: "<!-- BEGIN @przeprogramowani/10x-cli -->",
-    sentinelEnd: "<!-- END @przeprogramowani/10x-cli -->"
+    sentinelBegin: SENTINEL_BEGIN,
+    sentinelEnd: SENTINEL_END
   },
   generic: {
     toolId: "generic",
     displayName: "Other / Generic",
     skillPath: (n) => `.ai/skills/${n}/SKILL.md`,
+    skillDir: (n) => `.ai/skills/${n}`,
     promptPath: (n) => `.ai/prompts/${n}.md`,
     configPath: (n) => `.ai/config-templates/${n}`,
     rulesFile: "AGENTS.md",
     manifestDir: ".ai",
-    sentinelBegin: "<!-- BEGIN @przeprogramowani/10x-cli -->",
-    sentinelEnd: "<!-- END @przeprogramowani/10x-cli -->"
+    sentinelBegin: SENTINEL_BEGIN,
+    sentinelEnd: SENTINEL_END
   }
 };
 var DEFAULT_TOOL = "claude-code";
 
-// src/lib/tool-prompt.ts
-async function resolveToolProfile(flagOverride) {
-  if (flagOverride) {
-    const profile = PROFILES[flagOverride];
-    if (!profile) {
-      throw new Error(`Unknown tool '${flagOverride}'. Supported: ${Object.keys(PROFILES).join(", ")}`);
-    }
-    return profile;
-  }
-  const config = readToolConfig();
-  if (config?.tool && PROFILES[config.tool]) {
-    return PROFILES[config.tool];
+// src/lib/tool-detect.ts
+function detectTools(projectRoot) {
+  const hit = (rel) => existsSync4(join4(projectRoot, rel));
+  const signals = [];
+  if (hit(".claude/" + MANIFEST_FILENAME)) {
+    signals.push({
+      profileId: "claude-code",
+      confidence: "strong",
+      reason: ".claude/.10x-cli-manifest.json"
+    });
+  } else if (hit(".claude")) {
+    signals.push({ profileId: "claude-code", confidence: "medium", reason: ".claude/ directory" });
+  } else if (hit("CLAUDE.md")) {
+    signals.push({ profileId: "claude-code", confidence: "weak", reason: "CLAUDE.md" });
+  }
+  if (hit(".cursor/" + MANIFEST_FILENAME)) {
+    signals.push({
+      profileId: "cursor",
+      confidence: "strong",
+      reason: ".cursor/.10x-cli-manifest.json"
+    });
+  } else if (hit(".cursor/rules")) {
+    signals.push({ profileId: "cursor", confidence: "strong", reason: ".cursor/rules/" });
+  } else if (hit(".cursor")) {
+    signals.push({ profileId: "cursor", confidence: "medium", reason: ".cursor/ directory" });
+  }
+  if (hit(".github/" + MANIFEST_FILENAME)) {
+    signals.push({
+      profileId: "copilot",
+      confidence: "strong",
+      reason: ".github/.10x-cli-manifest.json"
+    });
+  } else if (hit(".github/copilot-instructions.md")) {
+    signals.push({
+      profileId: "copilot",
+      confidence: "strong",
+      reason: ".github/copilot-instructions.md"
+    });
+  } else if (hit(".github/skills") || hit(".github/prompts")) {
+    signals.push({
+      profileId: "copilot",
+      confidence: "medium",
+      reason: ".github/skills/ or .github/prompts/"
+    });
   }
-  if (process.stdout.isTTY) {
-    const choice = await de({
-      message: "Which AI coding tool do you use?",
-      options: Object.values(PROFILES).map((profile) => ({
-        value: profile.toolId,
-        label: profile.displayName,
-        hint: profile.toolId === DEFAULT_TOOL ? "default" : undefined
-      })),
-      initialValue: DEFAULT_TOOL
+  if (hit(".agents/" + MANIFEST_FILENAME)) {
+    signals.push({
+      profileId: "codex",
+      confidence: "strong",
+      reason: ".agents/.10x-cli-manifest.json"
     });
-    if (BD(choice)) {
-      ve("Using default (Claude Code).");
-      return PROFILES[DEFAULT_TOOL];
-    }
-    saveToolConfig({ tool: choice });
-    return PROFILES[choice];
+  } else if (hit(".agents")) {
+    signals.push({ profileId: "codex", confidence: "strong", reason: ".agents/ directory" });
+  } else if (hit("AGENTS.md") && !hit(".ai")) {
+    signals.push({ profileId: "codex", confidence: "medium", reason: "AGENTS.md" });
+  }
+  if (hit(".ai/" + MANIFEST_FILENAME)) {
+    signals.push({
+      profileId: "generic",
+      confidence: "strong",
+      reason: ".ai/.10x-cli-manifest.json"
+    });
+  } else if (hit(".ai")) {
+    signals.push({ profileId: "generic", confidence: "strong", reason: ".ai/ directory" });
+  } else if (hit("AGENTS.md") && !hit(".agents")) {
+    signals.push({ profileId: "generic", confidence: "weak", reason: "AGENTS.md (generic fallback)" });
   }
-  return PROFILES[DEFAULT_TOOL];
+  return rankSignals(signals);
+}
+var CONFIDENCE_ORDER = { strong: 3, medium: 2, weak: 1 };
+var PROFILE_ORDER = ["claude-code", "cursor", "copilot", "codex", "generic"];
+function rankSignals(signals) {
+  return [...signals].sort((a2, b2) => {
+    const c2 = CONFIDENCE_ORDER[b2.confidence] - CONFIDENCE_ORDER[a2.confidence];
+    if (c2 !== 0)
+      return c2;
+    return PROFILE_ORDER.indexOf(a2.profileId) - PROFILE_ORDER.indexOf(b2.profileId);
+  });
+}
+function topDetectedProfile(signals) {
+  const top = signals[0];
+  if (!top)
+    return null;
+  return PROFILES[top.profileId] ?? null;
 }
 
-// src/lib/writer.ts
+// src/lib/tool-switch.ts
 import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync3,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync3
+  existsSync as existsSync6,
+  lstatSync,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync5,
+  renameSync as renameSync2,
+  rmdirSync as rmdirSync2,
+  rmSync as rmSync3,
+  statSync,
+  writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { dirname as dirname4, join as join6 } from "node:path";
 
-// src/lib/manifest.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
-var MANIFEST_FILENAME = ".10x-cli-manifest.json";
-var CLI_PACKAGE_NAME = "@przeprogramowani/10x-cli";
-function readManifest(dir) {
-  const manifestPath = join3(dir, MANIFEST_FILENAME);
-  if (!existsSync3(manifestPath))
-    return null;
-  let raw;
-  try {
-    raw = readFileSync2(manifestPath, "utf8");
-  } catch {
-    return null;
-  }
-  let parsed;
+// src/lib/fs-utils.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+function readFileOrNull(path) {
   try {
-    parsed = JSON.parse(raw);
+    return readFileSync3(path, "utf8");
   } catch {
     return null;
   }
-  if (!isManifest(parsed))
-    return null;
-  return parsed;
-}
-function writeManifest(dir, manifest) {
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true });
-  }
-  const manifestPath = join3(dir, MANIFEST_FILENAME);
-  mkdirSync3(dirname2(manifestPath), { recursive: true });
-  writeFileSync2(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`);
-}
-function isManifest(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const v2 = value;
-  if (v2["package"] !== CLI_PACKAGE_NAME)
-    return false;
-  if (typeof v2["version"] !== "string")
-    return false;
-  if (typeof v2["lastApplied"] !== "string")
-    return false;
-  if (typeof v2["lessonId"] !== "string")
-    return false;
-  if (typeof v2["course"] !== "string")
-    return false;
-  const files = v2["files"];
-  if (typeof files !== "object" || files === null)
-    return false;
-  const f2 = files;
-  return isStringArray(f2["skills"]) && isStringArray(f2["prompts"]) && isStringArray(f2["configs"]);
-}
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
 
 // src/lib/sentinel-migration.ts
 var OLD_BEGIN = "<!-- BEGIN @przeprogramowani/10x-toolkit -->";
 var OLD_END = "<!-- END @przeprogramowani/10x-toolkit -->";
+function removeRulesBlockWithMarkers(existing, begin, end) {
+  const beginIdx = existing.indexOf(begin);
+  const endIdx = existing.indexOf(end);
+  if (beginIdx === -1 || endIdx === -1 || endIdx < beginIdx) {
+    return { content: existing, removed: false };
+  }
+  const beforeRaw = existing.slice(0, beginIdx);
+  const afterRaw = existing.slice(endIdx + end.length);
+  const before = beforeRaw.replace(/[\r\n]*$/, "");
+  const after = afterRaw.replace(/^[\r\n]*/, "");
+  const joiner = before.length > 0 && after.length > 0 ? `
+
+` : "";
+  const combined = before + joiner + after;
+  const content = combined.length === 0 ? "" : combined.replace(/[\r\n]*$/, `
+`);
+  return { content, removed: true };
+}
 function applyRulesBlockWithMarkers(existingContent, rulesBody, beginMarker, endMarker) {
   for (const marker of [OLD_BEGIN, OLD_END, beginMarker, endMarker]) {
     if (rulesBody.includes(marker)) {
@@ -4128,6 +4262,17 @@ function stripBlock(content, begin, end, label, warnings) {
 }
 
 // src/lib/writer.ts
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  readdirSync,
+  rmdirSync,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
 var CLI_VERSION = package_default.version;
 var DEFAULT_COURSE = "10xdevs3";
 function applyBundle(bundle, projectRoot, options = {}) {
@@ -4135,31 +4280,42 @@ function applyBundle(bundle, projectRoot, options = {}) {
   const partial = options.partial === true;
   const course = options.course ?? DEFAULT_COURSE;
   const profile = options.profile ?? PROFILES[DEFAULT_TOOL];
-  const manifestDir = join4(projectRoot, profile.manifestDir);
+  const manifestDir = join5(projectRoot, profile.manifestDir);
   const prevManifest = readManifest(manifestDir);
-  for (const skill of bundle.skills)
+  for (const skill of bundle.skills) {
     assertSafeName(skill.name, "skill");
+    for (const file of skill.files) {
+      assertSafeSkillFilePath(file.path, skill.name);
+    }
+  }
   for (const prompt of bundle.prompts)
     assertSafeName(prompt.name, "prompt");
   for (const config of bundle.configs)
     assertSafeName(config.name, "config");
   const skills = bundle.skills.map((skill) => {
-    const target = join4(projectRoot, profile.skillPath(skill.name));
-    const action = computeFileAction(target, skill.content);
-    if (!dryRun && action !== "unchanged") {
-      writeFileAt(target, skill.content);
-    }
-    return { name: skill.name, path: target, action };
+    const skillDir = join5(projectRoot, profile.skillDir(skill.name));
+    const fileWrites = skill.files.map((file) => {
+      const target = join5(skillDir, file.path);
+      const action = computeFileAction(target, file.content);
+      if (!dryRun && action !== "unchanged") {
+        writeFileAt(target, file.content);
+      }
+      if (!dryRun && file.executable === true && action !== "unchanged") {
+        chmodSync2(target, 493);
+      }
+      return { path: file.path, absolutePath: target, action };
+    });
+    return { name: skill.name, files: fileWrites };
   });
   const prompts = bundle.prompts.map((prompt) => {
-    const target = join4(projectRoot, profile.promptPath(prompt.name));
+    const target = join5(projectRoot, profile.promptPath(prompt.name));
     const action = computeFileAction(target, prompt.content);
     if (!dryRun && action !== "unchanged") {
       writeFileAt(target, prompt.content);
     }
     return { name: prompt.name, path: target, action };
   });
-  const rulesFilePath = join4(projectRoot, profile.rulesFile);
+  const rulesFilePath = join5(projectRoot, profile.rulesFile);
   const existingRules = readFileOrEmpty(rulesFilePath);
   let rulesAction;
   if (bundle.rules.length === 0) {
@@ -4181,8 +4337,8 @@ function applyBundle(bundle, projectRoot, options = {}) {
     }
   }
   const configs = bundle.configs.map((config) => {
-    const target = join4(projectRoot, profile.configPath(config.name));
-    const action = existsSync4(target) ? "skipped" : "created";
+    const target = join5(projectRoot, profile.configPath(config.name));
+    const action = existsSync5(target) ? "skipped" : "created";
     if (!dryRun && action === "created") {
       writeFileAt(target, config.content);
     }
@@ -4190,8 +4346,12 @@ function applyBundle(bundle, projectRoot, options = {}) {
   });
   if (!dryRun && !partial) {
     const removed = computeRemovals(prevManifest, bundle, profile, projectRoot);
-    for (const entry of removed.skills)
+    for (const entry of removed.skillDirs)
       rmSync2(entry.path, { recursive: true, force: true });
+    for (const entry of removed.skillFiles) {
+      rmSync2(entry.path, { force: true });
+      removeEmptyParentDirs(entry.path, entry.skillDirAbs);
+    }
     for (const entry of removed.prompts)
       rmSync2(entry.path, { force: true });
     for (const entry of removed.configs)
@@ -4201,12 +4361,13 @@ function applyBundle(bundle, projectRoot, options = {}) {
     const nextManifest = {
       package: CLI_PACKAGE_NAME,
       version: CLI_VERSION,
+      manifestVersion: MANIFEST_VERSION,
       lastApplied: new Date().toISOString(),
       lessonId: bundle.lessonId,
       course,
       tool: profile.toolId,
       files: {
-        skills: bundle.skills.map((s) => s.name),
+        skills: Object.fromEntries(bundle.skills.map((s) => [s.name, { files: s.files.map((f2) => f2.path) }])),
         prompts: bundle.prompts.map((p2) => `${p2.name}.md`),
         configs: bundle.configs.map((c2) => c2.name)
       }
@@ -4221,21 +4382,21 @@ function applyBundle(bundle, projectRoot, options = {}) {
   };
 }
 function computeFileAction(filePath, newContent) {
-  if (!existsSync4(filePath))
+  if (!existsSync5(filePath))
     return "created";
   let current;
   try {
-    current = readFileSync3(filePath, "utf8");
+    current = readFileSync4(filePath, "utf8");
   } catch {
     return "updated";
   }
   return current === newContent ? "unchanged" : "updated";
 }
 function readFileOrEmpty(filePath) {
-  if (!existsSync4(filePath))
+  if (!existsSync5(filePath))
     return "";
   try {
-    return readFileSync3(filePath, "utf8");
+    return readFileSync4(filePath, "utf8");
   } catch {
     return "";
   }
@@ -4245,20 +4406,43 @@ function writeFileAt(filePath, content) {
   writeFileSync3(filePath, content);
 }
 function computeRemovals(prevManifest, bundle, profile, projectRoot) {
-  const empty = { skills: [], prompts: [], configs: [] };
+  const empty = {
+    skillDirs: [],
+    skillFiles: [],
+    prompts: [],
+    configs: []
+  };
   if (!prevManifest)
     return empty;
-  const currentSkills = new Set(bundle.skills.map((s) => s.name));
+  const currentSkills = new Map(bundle.skills.map((s) => [s.name, new Set(s.files.map((f2) => f2.path))]));
   const currentPrompts = new Set(bundle.prompts.map((p2) => `${p2.name}.md`));
   const currentConfigs = new Set(bundle.configs.map((c2) => c2.name));
-  const removed = { skills: [], prompts: [], configs: [] };
-  for (const skillName of prevManifest.files.skills) {
-    if (currentSkills.has(skillName))
-      continue;
+  const removed = {
+    skillDirs: [],
+    skillFiles: [],
+    prompts: [],
+    configs: []
+  };
+  for (const [skillName, entry] of Object.entries(prevManifest.files.skills)) {
     if (!isSafeName(skillName))
       continue;
-    const skillTarget = join4(projectRoot, profile.skillPath(skillName));
-    removed.skills.push({ name: skillName, path: dirname3(skillTarget) });
+    const skillDirAbs = join5(projectRoot, profile.skillDir(skillName));
+    if (!currentSkills.has(skillName)) {
+      removed.skillDirs.push({ name: skillName, path: skillDirAbs });
+      continue;
+    }
+    const currentFiles = currentSkills.get(skillName);
+    for (const relPath of entry.files) {
+      if (currentFiles.has(relPath))
+        continue;
+      if (!isSafeSkillFilePath(relPath))
+        continue;
+      removed.skillFiles.push({
+        name: `${skillName}/${relPath}`,
+        path: join5(skillDirAbs, relPath),
+        skillDirAbs
+      });
+    }
   }
   for (const promptFile of prevManifest.files.prompts) {
     if (currentPrompts.has(promptFile))
@@ -4268,7 +4452,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
     const promptName = promptFile.replace(/\.md$/, "");
     removed.prompts.push({
       name: promptFile,
-      path: join4(projectRoot, profile.promptPath(promptName))
+      path: join5(projectRoot, profile.promptPath(promptName))
     });
   }
   for (const configFile of prevManifest.files.configs) {
@@ -4278,29 +4462,75 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
       continue;
     removed.configs.push({
       name: configFile,
-      path: join4(projectRoot, profile.configPath(configFile))
+      path: join5(projectRoot, profile.configPath(configFile))
     });
   }
   return removed;
 }
-function detectOrphanedArtifacts(projectRoot, currentProfile) {
+function removeEmptyParentDirs(filePath, skillDirAbs) {
+  let dir = dirname3(filePath);
+  while (dir.startsWith(skillDirAbs) && dir !== skillDirAbs) {
+    try {
+      if (readdirSync(dir).length > 0)
+        return;
+      rmdirSync(dir);
+    } catch {
+      return;
+    }
+    dir = dirname3(dir);
+  }
+}
+function findOrphanedManifests(projectRoot, currentProfile) {
+  const out = [];
   for (const profile of Object.values(PROFILES)) {
     if (profile.toolId === currentProfile.toolId)
       continue;
-    const otherManifest = join4(projectRoot, profile.manifestDir, MANIFEST_FILENAME);
-    if (existsSync4(otherManifest)) {
-      return `Found existing 10x artifacts in ${profile.manifestDir}/ from ${profile.displayName}.
-  Manually remove ${profile.manifestDir}/ if you no longer need it.
-  Your new artifacts will be written to ${currentProfile.manifestDir}/`;
-    }
+    const manifestPath = join5(projectRoot, profile.manifestDir, MANIFEST_FILENAME);
+    if (!existsSync5(manifestPath))
+      continue;
+    const manifest = readManifest(join5(projectRoot, profile.manifestDir));
+    if (!manifest)
+      continue;
+    out.push({ profile, manifestPath, manifest });
   }
-  return null;
+  return out;
+}
+function detectOrphanedArtifacts(projectRoot, currentProfile) {
+  const first = findOrphanedManifests(projectRoot, currentProfile)[0];
+  if (!first)
+    return null;
+  return `Found existing 10x artifacts in ${first.profile.manifestDir}/ from ${first.profile.displayName}.
+  Manually remove ${first.profile.manifestDir}/ if you no longer need it.
+  Your new artifacts will be written to ${currentProfile.manifestDir}/`;
 }
 function assertSafeName(name, kind) {
   if (!isSafeName(name)) {
     throw new Error(`refused to write unsafe ${kind} name ${JSON.stringify(name)} — must not be empty, contain path separators, or start with '.'`);
   }
 }
+function assertSafeSkillFilePath(relPath, skillName) {
+  if (!isSafeSkillFilePath(relPath)) {
+    throw new Error(`refused to write unsafe file path ${JSON.stringify(relPath)} inside skill ${JSON.stringify(skillName)}`);
+  }
+}
+function isSafeSkillFilePath(relPath) {
+  if (typeof relPath !== "string" || relPath.length === 0)
+    return false;
+  if (relPath.startsWith("/") || relPath.startsWith("\\"))
+    return false;
+  if (/^[a-zA-Z]:/.test(relPath))
+    return false;
+  const segments = relPath.split(/[/\\]/);
+  if (segments.length === 0)
+    return false;
+  for (const seg of segments) {
+    if (seg === "" || seg === "." || seg === "..")
+      return false;
+    if (!isSafeName(seg))
+      return false;
+  }
+  return true;
+}
 function isSafeName(name) {
   if (typeof name !== "string" || name.length === 0)
     return false;
@@ -4322,6 +4552,318 @@ function isSafeName(name) {
   return true;
 }
 
+// src/lib/tool-switch.ts
+function migrateArtifacts(projectRoot, orphan, newProfile) {
+  const summary = {
+    action: "migrated",
+    oldToolId: orphan.profile.toolId,
+    movedOrRemoved: { skills: [], prompts: [], configs: [] },
+    sentinelStripped: false,
+    skipped: []
+  };
+  const oldProfile = orphan.profile;
+  for (const [skillName, entry] of Object.entries(orphan.manifest.files.skills)) {
+    if (!isSafeName(skillName)) {
+      summary.skipped.push({ path: skillName, reason: "unsafe name in manifest" });
+      continue;
+    }
+    const fromSkillDir = join6(projectRoot, oldProfile.skillDir(skillName));
+    const toSkillDir = join6(projectRoot, newProfile.skillDir(skillName));
+    let anyMoved = false;
+    for (const relPath of entry.files) {
+      if (!isSafeSkillFilePath(relPath)) {
+        summary.skipped.push({
+          path: `${skillName}/${relPath}`,
+          reason: "unsafe path in manifest"
+        });
+        continue;
+      }
+      const from = join6(fromSkillDir, relPath);
+      const to = join6(toSkillDir, relPath);
+      if (moveIfSafe(from, to, summary.skipped))
+        anyMoved = true;
+    }
+    tryRemoveEmptyDir(fromSkillDir);
+    if (anyMoved)
+      summary.movedOrRemoved.skills.push(skillName);
+  }
+  for (const promptFile of orphan.manifest.files.prompts) {
+    if (!isSafeName(promptFile)) {
+      summary.skipped.push({ path: promptFile, reason: "unsafe name in manifest" });
+      continue;
+    }
+    const promptName = promptFile.replace(/\.md$/, "");
+    const from = join6(projectRoot, oldProfile.promptPath(promptName));
+    const to = join6(projectRoot, newProfile.promptPath(promptName));
+    if (moveIfSafe(from, to, summary.skipped)) {
+      summary.movedOrRemoved.prompts.push(promptFile);
+    }
+  }
+  for (const configFile of orphan.manifest.files.configs) {
+    if (!isSafeName(configFile)) {
+      summary.skipped.push({ path: configFile, reason: "unsafe name in manifest" });
+      continue;
+    }
+    const from = join6(projectRoot, oldProfile.configPath(configFile));
+    const to = join6(projectRoot, newProfile.configPath(configFile));
+    if (moveIfSafe(from, to, summary.skipped)) {
+      summary.movedOrRemoved.configs.push(configFile);
+    }
+  }
+  summary.sentinelStripped = stripSentinelFromRulesFile(projectRoot, oldProfile);
+  rmSync3(orphan.manifestPath, { force: true });
+  tryRemoveEmptyDir(join6(projectRoot, oldProfile.manifestDir));
+  return summary;
+}
+function deleteArtifacts(projectRoot, orphan) {
+  const summary = {
+    action: "deleted",
+    oldToolId: orphan.profile.toolId,
+    movedOrRemoved: { skills: [], prompts: [], configs: [] },
+    sentinelStripped: false,
+    skipped: []
+  };
+  const oldProfile = orphan.profile;
+  for (const [skillName, entry] of Object.entries(orphan.manifest.files.skills)) {
+    if (!isSafeName(skillName)) {
+      summary.skipped.push({ path: skillName, reason: "unsafe name in manifest" });
+      continue;
+    }
+    const skillDir = join6(projectRoot, oldProfile.skillDir(skillName));
+    for (const relPath of entry.files) {
+      if (!isSafeSkillFilePath(relPath)) {
+        summary.skipped.push({
+          path: `${skillName}/${relPath}`,
+          reason: "unsafe path in manifest"
+        });
+        continue;
+      }
+      rmSync3(join6(skillDir, relPath), { force: true });
+    }
+    rmSync3(skillDir, { recursive: true, force: true });
+    summary.movedOrRemoved.skills.push(skillName);
+  }
+  for (const promptFile of orphan.manifest.files.prompts) {
+    if (!isSafeName(promptFile)) {
+      summary.skipped.push({ path: promptFile, reason: "unsafe name in manifest" });
+      continue;
+    }
+    const promptName = promptFile.replace(/\.md$/, "");
+    rmSync3(join6(projectRoot, oldProfile.promptPath(promptName)), { force: true });
+    summary.movedOrRemoved.prompts.push(promptFile);
+  }
+  for (const configFile of orphan.manifest.files.configs) {
+    if (!isSafeName(configFile)) {
+      summary.skipped.push({ path: configFile, reason: "unsafe name in manifest" });
+      continue;
+    }
+    rmSync3(join6(projectRoot, oldProfile.configPath(configFile)), { force: true });
+    summary.movedOrRemoved.configs.push(configFile);
+  }
+  summary.sentinelStripped = stripSentinelFromRulesFile(projectRoot, oldProfile);
+  rmSync3(orphan.manifestPath, { force: true });
+  const manifestDirAbs = join6(projectRoot, oldProfile.manifestDir);
+  tryRemoveEmptyDir(join6(manifestDirAbs, "skills"));
+  tryRemoveEmptyDir(join6(manifestDirAbs, "prompts"));
+  tryRemoveEmptyDir(join6(manifestDirAbs, "config-templates"));
+  tryRemoveEmptyDir(manifestDirAbs);
+  return summary;
+}
+function moveIfSafe(from, to, skipped) {
+  if (!existsSync6(from)) {
+    return false;
+  }
+  if (lstatSync(from).isSymbolicLink()) {
+    skipped.push({ path: from, reason: "source is a symlink" });
+    return false;
+  }
+  if (existsSync6(to)) {
+    if (!filesAreIdentical(from, to)) {
+      skipped.push({
+        path: to,
+        reason: "destination already exists with different content"
+      });
+      return false;
+    }
+    rmSync3(from, { force: true });
+    return true;
+  }
+  mkdirSync5(dirname4(to), { recursive: true });
+  try {
+    renameSync2(from, to);
+  } catch (err) {
+    const code = err?.code;
+    if (code !== "EXDEV")
+      throw err;
+    const bytes = readFileSync5(from);
+    const tmp = `${to}.tmp`;
+    writeFileSync4(tmp, bytes);
+    renameSync2(tmp, to);
+    try {
+      rmSync3(from, { force: true });
+    } catch {
+      skipped.push({
+        path: from,
+        reason: "copied to destination but could not remove source"
+      });
+      return true;
+    }
+  }
+  return true;
+}
+function stripSentinelFromRulesFile(projectRoot, oldProfile) {
+  const rulesPath = join6(projectRoot, oldProfile.rulesFile);
+  if (!existsSync6(rulesPath))
+    return false;
+  const existing = readFileOrNull(rulesPath);
+  if (existing === null)
+    return false;
+  const { content, removed } = removeRulesBlockWithMarkers(existing, oldProfile.sentinelBegin, oldProfile.sentinelEnd);
+  if (!removed)
+    return false;
+  if (content.trim().length === 0) {
+    rmSync3(rulesPath, { force: true });
+  } else {
+    writeFileSync4(rulesPath, content);
+  }
+  return true;
+}
+function filesAreIdentical(a2, b2) {
+  try {
+    const aStat = statSync(a2);
+    const bStat = statSync(b2);
+    if (aStat.size !== bStat.size)
+      return false;
+    return readFileSync5(a2).equals(readFileSync5(b2));
+  } catch {
+    return false;
+  }
+}
+function tryRemoveEmptyDir(dir) {
+  if (!existsSync6(dir))
+    return;
+  try {
+    rmdirSync2(dir);
+  } catch {}
+}
+
+// src/lib/tool-prompt.ts
+async function resolveToolProfile(flagOverride, projectRoot = process.cwd()) {
+  const profile = await resolveProfileOnly(flagOverride, projectRoot);
+  await handleToolSwitch(projectRoot, profile);
+  return profile;
+}
+async function resolveProfileOnly(flagOverride, projectRoot) {
+  if (flagOverride) {
+    const profile = PROFILES[flagOverride];
+    if (!profile) {
+      throw new Error(`Unknown tool '${flagOverride}'. Supported: ${Object.keys(PROFILES).join(", ")}`);
+    }
+    return profile;
+  }
+  const config = readToolConfig();
+  if (config?.tool && PROFILES[config.tool]) {
+    return PROFILES[config.tool];
+  }
+  if (process.stdout.isTTY) {
+    const signals = detectTools(projectRoot);
+    const detected = topDetectedProfile(signals);
+    const top = signals[0];
+    if (top && detected) {
+      ye(`Detected: ${detected.displayName} (${top.reason})`);
+    }
+    const initial = detected?.toolId ?? DEFAULT_TOOL;
+    const choice = await de({
+      message: "Which AI coding tool do you use?",
+      options: Object.values(PROFILES).map((profile) => ({
+        value: profile.toolId,
+        label: profile.displayName,
+        hint: profile.toolId === initial ? "default" : undefined
+      })),
+      initialValue: initial
+    });
+    if (BD(choice)) {
+      ve("Using default (Claude Code).");
+      return PROFILES[DEFAULT_TOOL];
+    }
+    saveToolConfig({ ...config ?? {}, tool: choice });
+    return PROFILES[choice];
+  }
+  return PROFILES[DEFAULT_TOOL];
+}
+async function handleToolSwitch(projectRoot, newProfile) {
+  if (!process.stdout.isTTY)
+    return;
+  const cfg = readToolConfig();
+  const acknowledged = new Set(cfg?.acknowledgedOrphans ?? []);
+  const orphans = findOrphanedManifests(projectRoot, newProfile).filter((o) => !acknowledged.has(o.profile.toolId));
+  if (orphans.length === 0)
+    return;
+  for (const orphan of orphans) {
+    const action = await de({
+      message: `Found 10x artifacts from ${orphan.profile.displayName} in ${orphan.profile.manifestDir}/. What should we do?`,
+      options: [
+        {
+          value: "migrate",
+          label: `Migrate to ${newProfile.manifestDir}/`,
+          hint: "recommended"
+        },
+        {
+          value: "delete",
+          label: `Remove 10x artifacts from ${orphan.profile.manifestDir}/`
+        },
+        { value: "keep", label: "Keep both (don't ask again)" }
+      ],
+      initialValue: "migrate"
+    });
+    if (BD(action))
+      continue;
+    if (action === "migrate") {
+      const summary = migrateArtifacts(projectRoot, orphan, newProfile);
+      printMigrationSummary(summary, newProfile);
+    } else if (action === "delete") {
+      const summary = deleteArtifacts(projectRoot, orphan);
+      printMigrationSummary(summary, newProfile);
+    } else {
+      const existing = readToolConfig();
+      const nextAcks = [
+        ...existing?.acknowledgedOrphans ?? [],
+        orphan.profile.toolId
+      ];
+      saveToolConfig({
+        ...existing ?? {},
+        tool: existing?.tool ?? newProfile.toolId,
+        acknowledgedOrphans: nextAcks
+      });
+    }
+  }
+}
+function printMigrationSummary(summary, newProfile) {
+  const { skills, prompts, configs } = summary.movedOrRemoved;
+  const verb = summary.action === "migrated" ? "Moved" : "Removed";
+  const target = summary.action === "migrated" ? `to ${newProfile.manifestDir}/` : "";
+  const parts = [];
+  if (skills.length)
+    parts.push(`${skills.length} skill${skills.length === 1 ? "" : "s"}`);
+  if (prompts.length)
+    parts.push(`${prompts.length} prompt${prompts.length === 1 ? "" : "s"}`);
+  if (configs.length)
+    parts.push(`${configs.length} config${configs.length === 1 ? "" : "s"}`);
+  const lines = [];
+  if (parts.length > 0) {
+    lines.push(`${verb} ${parts.join(", ")}${target ? " " + target : ""}.`);
+  }
+  if (summary.sentinelStripped) {
+    lines.push(`Removed 10x block from the old rules file.`);
+  }
+  for (const s of summary.skipped) {
+    lines.push(`Skipped ${s.path} (${s.reason}).`);
+  }
+  if (lines.length > 0)
+    ye(lines.join(`
+`));
+}
+
 // src/commands/get.ts
 var ARTIFACT_TYPES = ["skills", "prompts", "rules", "configs"];
 function isArtifactType(s) {
@@ -4351,7 +4893,7 @@ async function runGet(ctx, ref, options) {
   }
   const auth = await requireAuth(ctx);
   const course = options.course ?? DEFAULT_COURSE2;
-  const profile = await resolveToolProfile(options.tool);
+  const profile = await resolveToolProfile(options.tool, process.cwd());
   const lang = options.lang ?? readToolConfig()?.lang ?? "en";
   if (options.lang) {
     const existing = readToolConfig();
@@ -4371,9 +4913,11 @@ async function runGet(ctx, ref, options) {
   if (isFallback && contentLang) {
     verbose(ctx, `${lang.toUpperCase()} not available for ${parsed.lessonId}, showing ${contentLang.toUpperCase()}.`);
   }
-  const orphanWarning = detectOrphanedArtifacts(process.cwd(), profile);
-  if (orphanWarning)
-    verbose(ctx, orphanWarning);
+  if (!process.stdout.isTTY) {
+    const orphanWarning = detectOrphanedArtifacts(process.cwd(), profile);
+    if (orphanWarning)
+      verbose(ctx, orphanWarning);
+  }
   const isFiltered = options.type !== undefined;
   const bundle = filterBundle(ctx, result.data, options);
   const writeResult = applyBundle(bundle, process.cwd(), {
@@ -4429,7 +4973,14 @@ async function runPrintMode(ctx, lessonId, course, profile, token, lang, options
     if (ctx.json) {
       output(ctx, "", result.data);
     } else {
-      process.stdout.write(result.data.content);
+      const data = result.data;
+      if (data.type === "skills") {
+        const skillMd = data.files.find((f2) => f2.path === "SKILL.md");
+        process.stdout.write(skillMd?.content ?? "");
+        emitMultiFileSkillNotice(data.name, data.files);
+      } else {
+        process.stdout.write(data.content);
+      }
     }
   } else {
     verbose(ctx, `fetching lesson ${course}/${lessonId} (filtering by ${options.type})`);
@@ -4437,17 +4988,40 @@ async function runPrintMode(ctx, lessonId, course, profile, token, lang, options
     if (!result.ok) {
       handleLessonError(ctx, result.status, result.code, result.error, result.payload);
     }
-    const artifacts = result.data[options.type];
-    if (ctx.json) {
-      output(ctx, "", artifacts);
+    const type = options.type;
+    if (type === "skills") {
+      const skills = result.data.skills;
+      if (ctx.json) {
+        output(ctx, "", skills);
+      } else {
+        const contents = skills.map((s) => s.files.find((f2) => f2.path === "SKILL.md")?.content ?? "");
+        process.stdout.write(contents.join(`
+---
+`));
+        for (const skill of skills)
+          emitMultiFileSkillNotice(skill.name, skill.files);
+      }
     } else {
-      const contents = artifacts.map((a2) => a2.content);
-      process.stdout.write(contents.join(`
+      const artifacts = result.data[type];
+      if (ctx.json) {
+        output(ctx, "", artifacts);
+      } else {
+        const contents = artifacts.map((a2) => a2.content);
+        process.stdout.write(contents.join(`
 ---
 `));
+      }
     }
   }
 }
+function emitMultiFileSkillNotice(skillName, files) {
+  const extras = files.filter((f2) => f2.path !== "SKILL.md").map((f2) => f2.path);
+  if (extras.length === 0)
+    return;
+  process.stderr.write(`Note: skill "${skillName}" has ${extras.length} additional file${extras.length === 1 ? "" : "s"} not shown in --print: ${extras.join(", ")}.
+` + `Run without --print to materialize all files.
+`);
+}
 function handleLessonError(ctx, status, code, error, payload) {
   verbose(ctx, `lesson fetch failed: status=${status} code=${code}`);
   if (status === 403) {
@@ -4514,7 +5088,15 @@ function renderGetResult(ctx, bundle, writeResult, dryRun, profile, langMeta = {
   lines.push("");
   lines.push(dryRun ? `Would write to ${targetDir}/:` : `Wrote to ${targetDir}/:`);
   for (const skill of writeResult.skills) {
-    lines.push(`  [${skill.action}] skill  ${skill.path}`);
+    if (skill.files.length === 1) {
+      const f2 = skill.files[0];
+      lines.push(`  [${f2.action}] skill  ${f2.absolutePath}`);
+    } else {
+      lines.push(`  skill  ${skill.name} (${skill.files.length} files)`);
+      for (const f2 of skill.files) {
+        lines.push(`    [${f2.action}] ${f2.path}`);
+      }
+    }
   }
   for (const prompt of writeResult.prompts) {
     lines.push(`  [${prompt.action}] prompt ${prompt.path}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@przeprogramowani/10x-cli",
-  "version": "0.5.0",
+  "version": "1.1.0",
   "description": "Open-source CLI for 10xDevs course content",
   "repository": {
     "type": "git",