@przeprogramowani/10x-cli 1.6.1 → 1.8.0

package/README.md

@@ -69,6 +69,7 @@ Once installed, just tell your agent to **set up 10x-cli** and it will pick up t
 | `--name <name>` | Filter by artifact name (requires `--type`) |
 | `--dry-run` | Show what would be written without touching the filesystem |
 | `--course <slug>` | Override the course slug (default: `10xdevs3`) |
+| `--no-course-rules` | Skip the course rules block in your rules file (`CLAUDE.md`/`AGENTS.md`); strips an existing one. Use `--course-rules` to re-enable. |
 
 #### Examples
 
@@ -88,8 +89,21 @@ Once installed, just tell your agent to **set up 10x-cli** and it will pick up t
 
 # Use with a different AI coding tool
 10x get m1l1 --tool cursor
+
+# Skip the course rules block (use only your rules). Persisted across runs;
+# a previously-applied block is stripped. Re-enable later with --course-rules.
+10x get m1l1 --no-course-rules
+10x get m1l2 --course-rules
+
+# An explicit rules request always applies, even with the opt-out persisted
+10x get m1l1 --type rules
 ```
 
+> The `--no-course-rules` / `--course-rules` choice is saved as `courseRules`
+> in `config.json` and applies to subsequent plain `10x get` runs. An explicit
+> `--type rules` request overrides the opt-out for that run. Skills, prompts,
+> and config-templates are unaffected.
+
 ### Global Flags
 
 - `--json` — Machine-readable JSON output (auto-detected when piped)

package/dist/index.mjs

@@ -2271,7 +2271,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "@przeprogramowani/10x-cli",
-  version: "1.6.1",
+  version: "1.8.0",
   description: "Open-source CLI for 10xDevs course content",
   repository: {
     type: "git",
@@ -2992,6 +2992,9 @@ function readToolConfig() {
     if (parsed.acknowledgedOrphans !== undefined && (!Array.isArray(parsed.acknowledgedOrphans) || !parsed.acknowledgedOrphans.every((x2) => typeof x2 === "string"))) {
       delete parsed.acknowledgedOrphans;
     }
+    if (parsed.courseRules !== undefined && typeof parsed.courseRules !== "boolean") {
+      delete parsed.courseRules;
+    }
     return parsed;
   } catch {
     return null;
@@ -3004,6 +3007,14 @@ function saveToolConfig(config) {
   }
   writeJsonAtomic(toolConfigPath(), config);
 }
+function updateToolConfig(patch) {
+  const current = readToolConfig();
+  const merged = { ...current, ...patch };
+  if (typeof merged.tool !== "string") {
+    throw new Error("updateToolConfig: refusing to persist a config without a `tool` — " + "no prior config exists and the patch did not seed one.");
+  }
+  saveToolConfig(merged);
+}
 
 // src/lib/api-client.ts
 var DEFAULT_API_BASE = "https://10x-toolkit-api.przeprogramowani.workers.dev";
@@ -4127,6 +4138,55 @@ function checkToolDirectory() {
   }
 }
 
+// src/commands/get.ts
+import { join as join7 } from "node:path";
+
+// src/lib/conflict-prompt.ts
+function createConflictResolver(tty) {
+  let applyToAll = null;
+  return async (info) => {
+    if (!tty)
+      return "skip";
+    if (applyToAll)
+      return applyToAll;
+    const choice = await de({
+      message: `${info.artifactType} ${info.artifactName} was modified locally.`,
+      options: [
+        { value: "overwrite", label: "Overwrite", hint: "replace local file with upstream content" },
+        { value: "save_user", label: "Save as .user copy", hint: "back up local version, then overwrite with upstream" },
+        { value: "skip", label: "Skip", hint: "keep local version, don't update" },
+        { value: "apply_all", label: "Apply to all remaining", hint: "use the previous choice for all subsequent conflicts" }
+      ]
+    });
+    if (BD(choice))
+      return "skip";
+    if (choice === "apply_all") {
+      const bulkChoice = await de({
+        message: "Which resolution for all remaining conflicts?",
+        options: [
+          { value: "overwrite", label: "Overwrite all" },
+          { value: "save_user", label: "Save .user copies for all" },
+          { value: "skip", label: "Skip all" }
+        ]
+      });
+      if (BD(bulkChoice))
+        return "skip";
+      applyToAll = bulkChoice;
+      return applyToAll;
+    }
+    return choice;
+  };
+}
+function showUpgradeNotice(tty) {
+  const msg = "First run after CLI update: content tracking is being established. " + "Files changed between lessons may trigger a conflict prompt this one time.";
+  if (tty) {
+    ye(msg);
+  } else {
+    process.stderr.write(`[verbose] ${msg}
+`);
+  }
+}
+
 // src/lib/lesson-ref.ts
 var MIN_MODULE = 0;
 var MAX_MODULE = 5;
@@ -4162,16 +4222,16 @@ 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 { createHash as createHash2 } from "node:crypto";
 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;
+var MANIFEST_VERSION = 3;
+function contentHash(content) {
+  return createHash2("sha256").update(content, "utf8").digest("hex");
+}
 function readManifest(dir) {
   const manifestPath = join3(dir, MANIFEST_FILENAME);
   if (!existsSync3(manifestPath))
@@ -4209,7 +4269,8 @@ function isManifest(value) {
     return false;
   if (typeof v2["version"] !== "string")
     return false;
-  if (v2["manifestVersion"] !== MANIFEST_VERSION)
+  const mv = v2["manifestVersion"];
+  if (mv !== 2 && mv !== 3)
     return false;
   if (typeof v2["lastApplied"] !== "string")
     return false;
@@ -4221,7 +4282,12 @@ function isManifest(value) {
   if (typeof files !== "object" || files === null)
     return false;
   const f2 = files;
-  return isSkillsRecord(f2["skills"]) && isStringArray(f2["prompts"]) && isStringArray(f2["configs"]);
+  if (!(isSkillsRecord(f2["skills"]) && isStringArray(f2["prompts"]) && isStringArray(f2["configs"])))
+    return false;
+  const lessons = v2["lessons"];
+  if (lessons !== undefined && !isLessonsRecord(lessons))
+    return false;
+  return true;
 }
 function isSkillsRecord(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
@@ -4238,8 +4304,58 @@ function isSkillsRecord(value) {
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+function isLessonFilesEntry(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const e2 = value;
+  if (typeof e2["appliedAt"] !== "string")
+    return false;
+  if (typeof e2["skills"] !== "object" || e2["skills"] === null || Array.isArray(e2["skills"]))
+    return false;
+  for (const skill of Object.values(e2["skills"])) {
+    if (typeof skill !== "object" || skill === null)
+      return false;
+    if (!isStringArray(skill["files"]))
+      return false;
+  }
+  return isStringArray(e2["prompts"]) && isStringArray(e2["configs"]);
+}
+function isLessonsRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  for (const entry of Object.values(value)) {
+    if (!isLessonFilesEntry(entry))
+      return false;
+  }
+  return true;
+}
+function buildUnionFiles(lessons) {
+  const skills = {};
+  const prompts = new Set;
+  const configs = new Set;
+  for (const entry of Object.values(lessons)) {
+    for (const [name, skill] of Object.entries(entry.skills)) {
+      if (!skills[name]) {
+        skills[name] = { files: [...skill.files] };
+      } else {
+        for (const f2 of skill.files) {
+          if (!skills[name].files.includes(f2)) {
+            skills[name].files.push(f2);
+          }
+        }
+      }
+    }
+    for (const p2 of entry.prompts)
+      prompts.add(p2);
+    for (const c2 of entry.configs)
+      configs.add(c2);
+  }
+  return { skills, prompts: [...prompts], configs: [...configs] };
+}
 
 // src/lib/tool-detect.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
 function detectTools(projectRoot) {
   const hit = (rel) => existsSync4(join4(projectRoot, rel));
   const signals = [];
@@ -4452,11 +4568,13 @@ import {
 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 = {}) {
+async function applyBundle(bundle, projectRoot, options = {}) {
   const dryRun = options.dryRun === true;
   const partial = options.partial === true;
   const course = options.course ?? DEFAULT_COURSE;
   const profile = options.profile ?? PROFILES[DEFAULT_TOOL];
+  const onConflict = options.onConflict;
+  const applyCourseRules = options.applyCourseRules !== false;
   const manifestDir = join5(projectRoot, profile.manifestDir);
   const prevManifest = readManifest(manifestDir);
   for (const skill of bundle.skills) {
@@ -4469,33 +4587,114 @@ function applyBundle(bundle, projectRoot, options = {}) {
     assertSafeName(prompt.name, "prompt");
   for (const config of bundle.configs)
     assertSafeName(config.name, "config");
-  const skills = bundle.skills.map((skill) => {
+  const nextSkillHashes = {};
+  const nextPromptHashes = {};
+  const skills = [];
+  for (const skill of bundle.skills) {
     const skillDir = join5(projectRoot, profile.skillDir(skill.name));
-    const fileWrites = skill.files.map((file) => {
+    const prevEntry = prevManifest?.files.skills[skill.name];
+    const fileWrites = [];
+    const skillHashes = {};
+    for (const file of skill.files) {
       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);
+      const storedHash = prevEntry?.contentHashes?.[file.path];
+      const { action, isConflict } = computeFileAction(target, file.content, storedHash);
+      let finalAction = action;
+      let userBackupPath;
+      if (isConflict) {
+        const resolution = onConflict ? await onConflict({
+          artifactType: "skill",
+          artifactName: `${skill.name}/${file.path}`,
+          filePath: target,
+          relativePath: file.path
+        }) : "skip";
+        if (resolution === "overwrite") {
+          finalAction = "conflict_overwritten";
+          if (!dryRun)
+            writeFileAt(target, file.content);
+          skillHashes[file.path] = contentHash(file.content);
+        } else if (resolution === "save_user") {
+          finalAction = "conflict_saved_user";
+          if (!dryRun) {
+            userBackupPath = buildUserBackupPath(target);
+            copyFileSync(target, userBackupPath);
+            writeFileAt(target, file.content);
+          }
+          skillHashes[file.path] = contentHash(file.content);
+        } else {
+          finalAction = "conflict_skipped";
+          if (storedHash)
+            skillHashes[file.path] = storedHash;
+        }
+      } else {
+        if (!dryRun && action !== "unchanged") {
+          writeFileAt(target, file.content);
+        }
+        if (!dryRun && file.executable === true && action !== "unchanged") {
+          chmodSync2(target, 493);
+        }
+        skillHashes[file.path] = contentHash(file.content);
       }
-      return { path: file.path, absolutePath: target, action };
-    });
-    return { name: skill.name, files: fileWrites };
-  });
-  const prompts = bundle.prompts.map((prompt) => {
+      fileWrites.push({ path: file.path, absolutePath: target, action: finalAction, userBackupPath });
+    }
+    nextSkillHashes[skill.name] = skillHashes;
+    skills.push({ name: skill.name, files: fileWrites });
+  }
+  const prompts = [];
+  for (const prompt of bundle.prompts) {
     const target = join5(projectRoot, profile.promptPath(prompt.name));
-    const action = computeFileAction(target, prompt.content);
-    if (!dryRun && action !== "unchanged") {
-      writeFileAt(target, prompt.content);
+    const promptFilename = `${prompt.name}.md`;
+    const storedHash = prevManifest?.files.promptHashes?.[promptFilename];
+    const { action, isConflict } = computeFileAction(target, prompt.content, storedHash);
+    let finalAction = action;
+    let userBackupPath;
+    if (isConflict) {
+      const resolution = onConflict ? await onConflict({
+        artifactType: "prompt",
+        artifactName: prompt.name,
+        filePath: target,
+        relativePath: promptFilename
+      }) : "skip";
+      if (resolution === "overwrite") {
+        finalAction = "conflict_overwritten";
+        if (!dryRun)
+          writeFileAt(target, prompt.content);
+        nextPromptHashes[promptFilename] = contentHash(prompt.content);
+      } else if (resolution === "save_user") {
+        finalAction = "conflict_saved_user";
+        if (!dryRun) {
+          userBackupPath = buildUserBackupPath(target);
+          copyFileSync(target, userBackupPath);
+          writeFileAt(target, prompt.content);
+        }
+        nextPromptHashes[promptFilename] = contentHash(prompt.content);
+      } else {
+        finalAction = "conflict_skipped";
+        if (storedHash)
+          nextPromptHashes[promptFilename] = storedHash;
+      }
+    } else {
+      if (!dryRun && action !== "unchanged") {
+        writeFileAt(target, prompt.content);
+      }
+      nextPromptHashes[promptFilename] = contentHash(prompt.content);
     }
-    return { name: prompt.name, path: target, action };
-  });
+    prompts.push({ name: prompt.name, path: target, action: finalAction, userBackupPath });
+  }
   const rulesFilePath = join5(projectRoot, profile.rulesFile);
   const existingRules = readFileOrEmpty(rulesFilePath);
   let rulesAction;
-  if (bundle.rules.length === 0) {
+  if (!applyCourseRules) {
+    const { content: stripped, removed: removed2 } = removeRulesBlockWithMarkers(existingRules, profile.sentinelBegin, profile.sentinelEnd);
+    if (removed2 && stripped !== existingRules) {
+      rulesAction = "removed";
+      if (!dryRun) {
+        writeFileAt(rulesFilePath, stripped);
+      }
+    } else {
+      rulesAction = "unchanged";
+    }
+  } else if (bundle.rules.length === 0) {
     rulesAction = "unchanged";
   } else {
     const rulesBody = bundle.rules.map((r2) => r2.content.trim()).join(`
@@ -4521,20 +4720,73 @@ function applyBundle(bundle, projectRoot, options = {}) {
     }
     return { name: config.name, path: target, action };
   });
-  if (!dryRun && !partial) {
-    const removed = computeRemovals(prevManifest, bundle, profile, projectRoot);
-    for (const entry of removed.skillDirs)
+  const removed = computeRemovals(prevManifest, bundle, profile, projectRoot);
+  const removalResult = {
+    skills: [],
+    prompts: [],
+    configs: []
+  };
+  for (const entry of removed.skillDirs) {
+    removalResult.skills.push({ name: entry.name, path: entry.path, action: "removed" });
+    if (!dryRun && !partial)
       rmSync2(entry.path, { recursive: true, force: true });
-    for (const entry of removed.skillFiles) {
+  }
+  for (const entry of removed.skillFiles) {
+    removalResult.skills.push({ name: entry.name, path: entry.path, action: "removed" });
+    if (!dryRun && !partial) {
       rmSync2(entry.path, { force: true });
       removeEmptyParentDirs(entry.path, entry.skillDirAbs);
     }
-    for (const entry of removed.prompts)
+  }
+  for (const entry of removed.prompts) {
+    removalResult.prompts.push({ name: entry.name, path: entry.path, action: "removed" });
+    if (!dryRun && !partial)
       rmSync2(entry.path, { force: true });
-    for (const entry of removed.configs)
+  }
+  for (const entry of removed.configs) {
+    removalResult.configs.push({ name: entry.name, path: entry.path, action: "removed" });
+    if (!dryRun && !partial)
       rmSync2(entry.path, { force: true });
   }
   if (!dryRun && !partial) {
+    const newLessonEntry = {
+      appliedAt: new Date().toISOString(),
+      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)
+    };
+    let baseLessons = {};
+    if (prevManifest && !prevManifest.lessons) {
+      baseLessons[prevManifest.lessonId] = {
+        appliedAt: prevManifest.lastApplied,
+        skills: Object.fromEntries(Object.entries(prevManifest.files.skills).map(([name, entry]) => [
+          name,
+          { files: [...entry.files] }
+        ])),
+        prompts: [...prevManifest.files.prompts],
+        configs: [...prevManifest.files.configs]
+      };
+    } else if (prevManifest?.lessons) {
+      baseLessons = { ...prevManifest.lessons };
+    }
+    const lessons = {
+      ...baseLessons,
+      [bundle.lessonId]: newLessonEntry
+    };
+    const union = buildUnionFiles(lessons);
+    const unionSkills = {};
+    for (const [name, skill] of Object.entries(union.skills)) {
+      const prevHash = prevManifest?.files.skills[name]?.contentHashes;
+      const currentHash = nextSkillHashes[name];
+      unionSkills[name] = {
+        files: skill.files,
+        contentHashes: { ...prevHash, ...currentHash }
+      };
+    }
+    const unionPromptHashes = {
+      ...prevManifest?.files.promptHashes,
+      ...nextPromptHashes
+    };
     const nextManifest = {
       package: CLI_PACKAGE_NAME,
       version: CLI_VERSION,
@@ -4544,10 +4796,12 @@ function applyBundle(bundle, projectRoot, options = {}) {
       course,
       tool: profile.toolId,
       files: {
-        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)
-      }
+        skills: unionSkills,
+        prompts: union.prompts,
+        configs: union.configs,
+        promptHashes: unionPromptHashes
+      },
+      lessons
     };
     writeManifest(manifestDir, nextManifest);
   }
@@ -4555,19 +4809,38 @@ function applyBundle(bundle, projectRoot, options = {}) {
     skills,
     prompts,
     rules: { action: rulesAction },
-    configs
+    configs,
+    removals: removalResult
   };
 }
-function computeFileAction(filePath, newContent) {
+function computeFileAction(filePath, newContent, storedHash) {
   if (!existsSync5(filePath))
-    return "created";
+    return { action: "created", isConflict: false };
   let current;
   try {
     current = readFileSync4(filePath, "utf8");
   } catch {
-    return "updated";
+    return { action: "updated", isConflict: false };
+  }
+  if (current === newContent)
+    return { action: "unchanged", isConflict: false };
+  if (storedHash !== undefined) {
+    const localHash = contentHash(current);
+    if (localHash === storedHash)
+      return { action: "updated", isConflict: false };
+    return { action: "updated", isConflict: true };
   }
-  return current === newContent ? "unchanged" : "updated";
+  return { action: "updated", isConflict: true };
+}
+function buildUserBackupPath(filePath) {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1)
+    return `${filePath}.user`;
+  return `${filePath.slice(0, lastDot)}.user${filePath.slice(lastDot)}`;
+}
+function copyFileSync(src, dest) {
+  mkdirSync4(dirname3(dest), { recursive: true });
+  writeFileSync3(dest, readFileSync4(src));
 }
 function readFileOrEmpty(filePath) {
   if (!existsSync5(filePath))
@@ -4589,8 +4862,28 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
     prompts: [],
     configs: []
   };
-  if (!prevManifest)
+  if (!prevManifest?.lessons)
     return empty;
+  const prevLessonEntry = prevManifest.lessons[bundle.lessonId];
+  if (!prevLessonEntry)
+    return empty;
+  const protectedSkills = new Map;
+  const protectedPrompts = new Set;
+  const protectedConfigs = new Set;
+  for (const [lessonId, entry] of Object.entries(prevManifest.lessons)) {
+    if (lessonId === bundle.lessonId)
+      continue;
+    for (const [name, skill] of Object.entries(entry.skills)) {
+      if (!protectedSkills.has(name))
+        protectedSkills.set(name, new Set);
+      for (const f2 of skill.files)
+        protectedSkills.get(name).add(f2);
+    }
+    for (const p2 of entry.prompts)
+      protectedPrompts.add(p2);
+    for (const c2 of entry.configs)
+      protectedConfigs.add(c2);
+  }
   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));
@@ -4600,18 +4893,35 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
     prompts: [],
     configs: []
   };
-  for (const [skillName, entry] of Object.entries(prevManifest.files.skills)) {
+  for (const [skillName, skill] of Object.entries(prevLessonEntry.skills)) {
     if (!isSafeName(skillName))
       continue;
     const skillDirAbs = join5(projectRoot, profile.skillDir(skillName));
     if (!currentSkills.has(skillName)) {
-      removed.skillDirs.push({ name: skillName, path: skillDirAbs });
+      if (protectedSkills.has(skillName)) {
+        const prot = protectedSkills.get(skillName);
+        for (const relPath of skill.files) {
+          if (prot.has(relPath))
+            continue;
+          if (!isSafeSkillFilePath(relPath))
+            continue;
+          removed.skillFiles.push({
+            name: `${skillName}/${relPath}`,
+            path: join5(skillDirAbs, relPath),
+            skillDirAbs
+          });
+        }
+      } else {
+        removed.skillDirs.push({ name: skillName, path: skillDirAbs });
+      }
       continue;
     }
     const currentFiles = currentSkills.get(skillName);
-    for (const relPath of entry.files) {
+    for (const relPath of skill.files) {
       if (currentFiles.has(relPath))
         continue;
+      if (protectedSkills.get(skillName)?.has(relPath))
+        continue;
       if (!isSafeSkillFilePath(relPath))
         continue;
       removed.skillFiles.push({
@@ -4621,9 +4931,11 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
       });
     }
   }
-  for (const promptFile of prevManifest.files.prompts) {
+  for (const promptFile of prevLessonEntry.prompts) {
     if (currentPrompts.has(promptFile))
       continue;
+    if (protectedPrompts.has(promptFile))
+      continue;
     if (!isSafeName(promptFile))
       continue;
     const promptName = promptFile.replace(/\.md$/, "");
@@ -4632,9 +4944,11 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
       path: join5(projectRoot, profile.promptPath(promptName))
     });
   }
-  for (const configFile of prevManifest.files.configs) {
+  for (const configFile of prevLessonEntry.configs) {
     if (currentConfigs.has(configFile))
       continue;
+    if (protectedConfigs.has(configFile))
+      continue;
     if (!isSafeName(configFile))
       continue;
     removed.configs.push({
@@ -5054,9 +5368,16 @@ var ARTIFACT_TYPES = ["skills", "prompts", "rules", "configs"];
 function isArtifactType(s) {
   return ARTIFACT_TYPES.includes(s);
 }
+function resolveCourseRulesFlag(argv) {
+  if (argv.includes("--no-course-rules"))
+    return false;
+  if (argv.includes("--course-rules"))
+    return true;
+  return;
+}
 var DEFAULT_COURSE2 = "10xdevs3";
 function registerGetCommand(cli) {
-  cli.command("get <ref>", "Fetch and apply a lesson pack").option("--dry-run", "Show what would be written without touching the filesystem").option("--course <course>", "Override the course slug (default: 10xdevs3)").option("--tool <tool>", "AI coding tool (claude-code, cursor, copilot, codex, windsurf, gemini, generic)").option("--print", "Print artifact content to stdout instead of writing to files").option("--type <type>", "Artifact type filter: skills, prompts, rules, configs").option("--name <name>", "Artifact name filter (requires --type)").option("--lang <lang>", "Content language: en (default) or pl").action(async (ref, options) => {
+  cli.command("get <ref>", "Fetch and apply a lesson pack").option("--dry-run", "Show what would be written without touching the filesystem").option("--course <course>", "Override the course slug (default: 10xdevs3)").option("--tool <tool>", "AI coding tool (claude-code, cursor, copilot, codex, windsurf, gemini, generic)").option("--print", "Print artifact content to stdout instead of writing to files").option("--type <type>", "Artifact type filter: skills, prompts, rules, configs").option("--name <name>", "Artifact name filter (requires --type)").option("--lang <lang>", "Content language: en (default) or pl").option("--no-course-rules", "Skip applying the course rules block to your rules file (CLAUDE.md/AGENTS.md)").action(async (ref, options) => {
     const ctx = resolveContext(options);
     await runGet(ctx, ref, options);
   });
@@ -5079,10 +5400,18 @@ async function runGet(ctx, ref, options) {
   const auth = await requireAuth(ctx);
   const course = options.course ?? DEFAULT_COURSE2;
   const profile = await resolveToolProfile(options.tool, process.cwd());
+  const dryRun = options.dryRun === true;
   const lang = options.lang ?? readToolConfig()?.lang ?? "en";
-  if (options.lang) {
-    const existing = readToolConfig();
-    saveToolConfig({ tool: existing?.tool ?? profile.toolId, lang: options.lang });
+  const explicitCourseRules = resolveCourseRulesFlag(process.argv);
+  const resolvedCourseRules = explicitCourseRules ?? readToolConfig()?.courseRules ?? true;
+  if (!dryRun && (options.lang || explicitCourseRules !== undefined)) {
+    const tool = readToolConfig()?.tool ?? profile.toolId;
+    const patch = { tool };
+    if (options.lang)
+      patch.lang = options.lang;
+    if (explicitCourseRules !== undefined)
+      patch.courseRules = explicitCourseRules;
+    updateToolConfig(patch);
   }
   if (options.print) {
     await runPrintMode(ctx, parsed.lessonId, course, profile, auth.access_token, lang, options);
@@ -5108,14 +5437,23 @@ async function runGet(ctx, ref, options) {
   }
   const isFiltered = options.type !== undefined;
   const bundle = filterBundle(ctx, result.data, options);
-  const writeResult = applyBundle(bundle, process.cwd(), {
-    dryRun: options.dryRun === true,
+  const isTTY = process.stdout.isTTY === true;
+  const prevManifest = readManifest(join7(process.cwd(), profile.manifestDir));
+  if (prevManifest && prevManifest.manifestVersion === 2) {
+    showUpgradeNotice(isTTY);
+  }
+  const applyCourseRules = isFiltered ? true : resolvedCourseRules;
+  const writeResult = await applyBundle(bundle, process.cwd(), {
+    dryRun,
     profile,
-    partial: isFiltered
+    partial: isFiltered,
+    onConflict: createConflictResolver(isTTY),
+    applyCourseRules
   });
-  renderGetResult(ctx, bundle, writeResult, options.dryRun === true, profile, {
+  renderGetResult(ctx, bundle, writeResult, dryRun, profile, {
     language: contentLang ?? lang,
-    languageFallback: isFallback
+    languageFallback: isFallback,
+    applyCourseRules
   });
 }
 function filterBundle(ctx, bundle, options) {
@@ -5243,7 +5581,25 @@ function handleLessonError(ctx, status, code, error, payload) {
   }
   outputError(ctx, code || "lesson_fetch_failed", "Failed to fetch the lesson bundle.", ExitCodes.ERROR, error ? `Server said: ${error}` : undefined);
 }
-function renderGetResult(ctx, bundle, writeResult, dryRun, profile, langMeta = { language: "en", languageFallback: false }) {
+function formatAction(action) {
+  switch (action) {
+    case "conflict_overwritten":
+      return "conflict: overwritten";
+    case "conflict_saved_user":
+      return "conflict: saved .user";
+    case "conflict_skipped":
+      return "conflict: skipped";
+    default:
+      return action;
+  }
+}
+function renderGetResult(ctx, bundle, writeResult, dryRun, profile, langMeta = {
+  language: "en",
+  languageFallback: false,
+  applyCourseRules: true
+}) {
+  const applyCourseRules = langMeta.applyCourseRules;
+  const totalRemovals = writeResult.removals.skills.length + writeResult.removals.prompts.length + writeResult.removals.configs.length;
   if (ctx.json) {
     output(ctx, "", {
       lessonId: bundle.lessonId,
@@ -5257,13 +5613,15 @@ function renderGetResult(ctx, bundle, writeResult, dryRun, profile, langMeta = {
         skills: writeResult.skills,
         prompts: writeResult.prompts,
         rules: writeResult.rules,
-        configs: writeResult.configs
+        configs: writeResult.configs,
+        removals: writeResult.removals
       },
       counts: {
         skills: writeResult.skills.length,
         prompts: writeResult.prompts.length,
-        rules: bundle.rules.length,
-        configs: writeResult.configs.length
+        rules: applyCourseRules ? bundle.rules.length : 0,
+        configs: writeResult.configs.length,
+        removals: totalRemovals
       }
     });
     return;
@@ -5278,23 +5636,38 @@ function renderGetResult(ctx, bundle, writeResult, dryRun, profile, langMeta = {
   for (const skill of writeResult.skills) {
     if (skill.files.length === 1) {
       const f2 = skill.files[0];
-      lines.push(`  [${f2.action}] skill  ${f2.absolutePath}`);
+      lines.push(`  [${formatAction(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}`);
+        lines.push(`    [${formatAction(f2.action)}] ${f2.path}`);
       }
     }
   }
   for (const prompt of writeResult.prompts) {
-    lines.push(`  [${prompt.action}] prompt ${prompt.path}`);
+    lines.push(`  [${formatAction(prompt.action)}] prompt ${prompt.path}`);
   }
-  if (bundle.rules.length > 0) {
+  if (!applyCourseRules) {
+    if (writeResult.rules.action === "removed") {
+      lines.push(`  [removed] rules  ${profile.rulesFile}`);
+    } else {
+      verbose(ctx, `course rules disabled — ${profile.rulesFile} left untouched`);
+    }
+  } else if (bundle.rules.length > 0) {
     lines.push(`  [${writeResult.rules.action}] rules  ${profile.rulesFile} (${bundle.rules.length} block${bundle.rules.length === 1 ? "" : "s"})`);
   }
   for (const config of writeResult.configs) {
     lines.push(`  [${config.action}] config ${config.path}`);
   }
+  for (const entry of writeResult.removals.skills) {
+    lines.push(`  [removed] skill  ${entry.path}`);
+  }
+  for (const entry of writeResult.removals.prompts) {
+    lines.push(`  [removed] prompt ${entry.path}`);
+  }
+  for (const entry of writeResult.removals.configs) {
+    lines.push(`  [removed] config ${entry.path}`);
+  }
   output(ctx, lines.join(`
 `), undefined);
 }

package/package.json

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