@kurokeita/add-skill 1.18.0 → 1.20.0

package/dist/bin/cli.js

@@ -1,27 +1,27 @@
 #!/usr/bin/env node
 
 // bin/cli.ts
-import { intro as intro5, isCancel as isCancel5, outro as outro5, select as select5 } from "@clack/prompts";
+import { intro as intro5, isCancel as isCancel6, outro as outro5, select as select6 } from "@clack/prompts";
 import { Command } from "commander";
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 
 // src/commands/add.ts
-import os3 from "node:os";
+import os4 from "node:os";
 import path6 from "node:path";
 import {
   autocompleteMultiselect,
   cancel,
   confirm,
   intro,
-  isCancel,
+  isCancel as isCancel2,
   multiselect,
-  note,
+  note as note2,
   outro,
-  select,
+  select as select2,
   spinner
 } from "@clack/prompts";
 import fs4 from "fs-extra";
-import pc from "picocolors";
+import pc2 from "picocolors";
 
 // src/utils/github.ts
 import os from "node:os";
@@ -148,12 +148,50 @@ var PLATFORM_PATHS_WORKFLOWS = {
   gemini: path2.join(os2.homedir(), ".gemini/commands"),
   windsurf: path2.join(os2.homedir(), ".codeium/windsurf/global_workflows")
 };
+var PROJECT_RELATIVE_PLATFORM_PATHS_SKILLS = {
+  antigravity: ".gemini/antigravity/skills",
+  "claude-code": ".claude/skills",
+  codex: ".codex/skills",
+  copilot: ".copilot/skills",
+  gemini: ".gemini/skills",
+  windsurf: ".codeium/windsurf/skills"
+};
+var PROJECT_RELATIVE_PLATFORM_PATHS_AGENTS = {
+  "claude-code": ".claude/agents",
+  codex: ".codex/skills",
+  copilot: ".copilot/agents",
+  gemini: ".gemini/agents"
+};
+var PROJECT_RELATIVE_PLATFORM_PATHS_WORKFLOWS = {
+  antigravity: ".gemini/antigravity/workflows",
+  "claude-code": ".claude/skills",
+  codex: ".codex/skills",
+  copilot: ".copilot/prompts",
+  gemini: ".gemini/commands",
+  windsurf: ".codeium/windsurf/workflows"
+};
+function resolveProjectPaths(relative, root) {
+  const out = {};
+  for (const [platform, rel] of Object.entries(relative)) {
+    if (rel) out[platform] = path2.join(root, rel);
+  }
+  return out;
+}
+function getProjectPlatformPathsSkills(root) {
+  return resolveProjectPaths(PROJECT_RELATIVE_PLATFORM_PATHS_SKILLS, root);
+}
+function getProjectPlatformPathsAgents(root) {
+  return resolveProjectPaths(PROJECT_RELATIVE_PLATFORM_PATHS_AGENTS, root);
+}
+function getProjectPlatformPathsWorkflows(root) {
+  return resolveProjectPaths(PROJECT_RELATIVE_PLATFORM_PATHS_WORKFLOWS, root);
+}
 var TYPE_DIRS = {
   skill: path2.join(PROJECT_ROOT, "skills"),
   agent: path2.join(PROJECT_ROOT, "agents"),
   workflow: path2.join(PROJECT_ROOT, "workflows")
 };
-function getTargetPaths(type) {
+function getGlobalTargetPaths(type) {
   switch (type) {
     case "agent":
       return PLATFORM_PATHS_AGENTS;
@@ -163,6 +201,23 @@ function getTargetPaths(type) {
       return PLATFORM_PATHS_SKILLS;
   }
 }
+function getProjectTargetPaths(type, root) {
+  switch (type) {
+    case "agent":
+      return getProjectPlatformPathsAgents(root);
+    case "workflow":
+      return getProjectPlatformPathsWorkflows(root);
+    default:
+      return getProjectPlatformPathsSkills(root);
+  }
+}
+function getTargetPaths(type, scope = "global", projectRoot) {
+  if (scope === "project") {
+    const root = projectRoot ?? process.cwd();
+    return getProjectTargetPaths(type, root);
+  }
+  return getGlobalTargetPaths(type);
+}
 
 // src/utils/platforms/antigravity.ts
 var AntigravityHandler = class {
@@ -683,6 +738,197 @@ function enableAutocompleteMultiSelectShiftAToggle() {
   autocompletePromptPrototype.__aiManagerShiftAPatched__ = true;
 }
 
+// src/utils/scope-prompt.ts
+import { isCancel, note, select } from "@clack/prompts";
+import pc from "picocolors";
+
+// src/utils/scope.ts
+import { execFileSync } from "node:child_process";
+import os3 from "node:os";
+function isInsideGitWorkTree(cwd) {
+  try {
+    const out = execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8"
+    });
+    return out.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+function resolveScope(scope, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  if (scope === "global") {
+    return { ok: true, scope: "global", root: options.homedir ?? os3.homedir() };
+  }
+  const home = options.homedir ?? os3.homedir();
+  if (cwd === home) {
+    return { ok: false, reason: "homedir" };
+  }
+  const gitCheck = options.gitCheck ?? isInsideGitWorkTree;
+  if (!gitCheck(cwd)) {
+    return { ok: false, reason: "not-a-git-repo" };
+  }
+  return { ok: true, scope: "project", root: cwd };
+}
+function describeRefusal(reason) {
+  switch (reason) {
+    case "homedir":
+      return "Project scope is not allowed when the current directory is your home directory.";
+    case "not-a-git-repo":
+      return "Project scope requires running inside a git repository.";
+  }
+}
+
+// src/utils/scope-prompt.ts
+function isValidScopeFlag(value) {
+  return value === "global" || value === "project";
+}
+function isValidListRemoveScopeFlag(value) {
+  return value === "global" || value === "project" || value === "both";
+}
+async function pickScope(initial) {
+  const result = await select({
+    message: "Choose install scope:",
+    options: [
+      {
+        label: "Global",
+        value: "global",
+        hint: "install under your home directory (default)"
+      },
+      {
+        label: "Project",
+        value: "project",
+        hint: "install under the current project directory"
+      }
+    ],
+    initialValue: initial
+  });
+  if (isCancel(result)) return "__cancel__";
+  return result;
+}
+async function offerGlobalFallback(reason) {
+  note(reason, "Project scope unavailable");
+  const choice = await select({
+    message: "What would you like to do?",
+    options: [
+      { label: "Install at global scope instead", value: "global" },
+      { label: "Cancel", value: "cancel" }
+    ],
+    initialValue: "global"
+  });
+  if (isCancel(choice) || choice === "cancel") return "__cancel__";
+  return "global";
+}
+async function chooseInstallScope(options = {}) {
+  const requested = options.flag ?? await pickScope(options.initial ?? "global");
+  if (requested === "__cancel__") return { cancelled: true };
+  const resolution = resolveScope(requested, options);
+  if (resolution.ok) {
+    return {
+      cancelled: false,
+      scope: resolution.scope,
+      root: resolution.root
+    };
+  }
+  if (options.flag === "project") {
+    const reason = describeRefusal(resolution.reason);
+    note(pc.yellow(reason), "Project scope unavailable");
+    return { rejected: true, reason };
+  }
+  const fallback = await offerGlobalFallback(describeRefusal(resolution.reason));
+  if (fallback === "__cancel__") return { cancelled: true };
+  const fallbackResolution = resolveScope("global", options);
+  if (!fallbackResolution.ok) return { cancelled: true };
+  return {
+    cancelled: false,
+    scope: fallbackResolution.scope,
+    root: fallbackResolution.root
+  };
+}
+async function pickListRemoveScope(action) {
+  const verb = action === "list" ? "List" : "Remove from";
+  const result = await select({
+    message: `Choose scope to ${action === "list" ? "list" : "remove from"}:`,
+    options: [
+      {
+        label: "Global",
+        value: "global",
+        hint: `${verb} items installed under your home directory`
+      },
+      {
+        label: "Project",
+        value: "project",
+        hint: `${verb} items under the current project`
+      },
+      {
+        label: "Both",
+        value: "both",
+        hint: `${verb} items at both scopes`
+      }
+    ],
+    initialValue: "global"
+  });
+  if (isCancel(result)) return "__cancel__";
+  return result;
+}
+async function offerGlobalOnlyFallback(reason, action) {
+  note(reason, "Project scope unavailable");
+  const verb = action === "list" ? "List" : "Remove from";
+  const choice = await select({
+    message: "What would you like to do?",
+    options: [
+      { label: `${verb} global scope only`, value: "global" },
+      { label: "Cancel", value: "cancel" }
+    ],
+    initialValue: "global"
+  });
+  if (isCancel(choice) || choice === "cancel") return "__cancel__";
+  return "global";
+}
+async function chooseListRemoveScope(options) {
+  const requested = options.flag ?? await pickListRemoveScope(options.action);
+  if (requested === "__cancel__") return { cancelled: true };
+  if (requested === "global") {
+    const resolved = resolveScope("global", options);
+    if (!resolved.ok) return { cancelled: true };
+    return {
+      cancelled: false,
+      scope: "global",
+      homedir: resolved.root
+    };
+  }
+  const projectResolution = resolveScope("project", options);
+  if (projectResolution.ok) {
+    const homeResolution2 = resolveScope("global", options);
+    if (!homeResolution2.ok) return { cancelled: true };
+    return {
+      cancelled: false,
+      scope: requested,
+      homedir: homeResolution2.root,
+      projectRoot: projectResolution.root
+    };
+  }
+  if (options.flag) {
+    const reason = describeRefusal(projectResolution.reason);
+    note(pc.yellow(reason), "Project scope unavailable");
+    return { rejected: true, reason };
+  }
+  const fallback = await offerGlobalOnlyFallback(
+    describeRefusal(projectResolution.reason),
+    options.action
+  );
+  if (fallback === "__cancel__") return { cancelled: true };
+  const homeResolution = resolveScope("global", options);
+  if (!homeResolution.ok) return { cancelled: true };
+  return {
+    cancelled: false,
+    scope: "global",
+    homedir: homeResolution.root
+  };
+}
+
 // src/commands/add.ts
 enableAutocompleteMultiSelectShiftAToggle();
 function getPlatformOptions(type) {
@@ -690,7 +936,7 @@ function getPlatformOptions(type) {
   return Object.entries(paths).filter(([_, pathStr]) => !!pathStr).map(([platform, pathStr]) => ({
     label: PLATFORM_LABELS[platform],
     value: platform,
-    hint: pathStr.replace(os3.homedir(), "~")
+    hint: pathStr.replace(os4.homedir(), "~")
   }));
 }
 async function installItem(itemName, overwrite, sourcePath, targetBaseDir) {
@@ -707,13 +953,13 @@ async function installItem(itemName, overwrite, sourcePath, targetBaseDir) {
 }
 async function add(type, url, options) {
   if (!options?.skipIntro) {
-    intro(pc.bgCyan(pc.black(" AI Manager : Add ")));
+    intro(pc2.bgCyan(pc2.black(" AI Manager : Add ")));
   }
   let currentType = type;
   const isSingleShot = !!type || !!url;
   while (true) {
     if (!currentType && !url) {
-      const selectedType = await select({
+      const selectedType = await select2({
         message: "What would you like to add?",
         options: [
           { label: "Skills", value: "skill" },
@@ -722,7 +968,7 @@ async function add(type, url, options) {
           { label: "Exit", value: "exit" }
         ]
       });
-      if (isCancel(selectedType) || selectedType === "exit") {
+      if (isCancel2(selectedType) || selectedType === "exit") {
         break;
       }
       currentType = selectedType;
@@ -743,7 +989,7 @@ async function add(type, url, options) {
           const result = await fetchSkillFromGitHub(url);
           tempDir = result.tempDir;
           selectedItems = [result.skillName];
-          s2.stop(pc.green(`Fetched ${normalizedType}: ${result.skillName}`));
+          s2.stop(pc2.green(`Fetched ${normalizedType}: ${result.skillName}`));
         } catch (e) {
           s2.error("Failed to fetch");
           throw e;
@@ -760,7 +1006,7 @@ async function add(type, url, options) {
           (entry) => entry.isDirectory() || (normalizedType === "workflow" || normalizedType === "agent") && entry.isFile() && entry.name.endsWith(".md")
         ).map((entry) => ({ label: entry.name, value: entry.name })).sort((a, b) => a.label.localeCompare(b.label));
         if (availableItems.length === 0) {
-          note(`No ${normalizedType}s found in directory.`, "Information");
+          note2(`No ${normalizedType}s found in directory.`, "Information");
           if (isSingleShot) break;
           currentType = void 0;
           continue;
@@ -769,14 +1015,13 @@ async function add(type, url, options) {
           message: `Select ${normalizedType}s to install:`,
           options: availableItems
         });
-        if (isCancel(items)) {
+        if (isCancel2(items)) {
           if (isSingleShot) break;
           currentType = void 0;
           continue;
         }
         selectedItems = items;
       }
-      const supportedPaths = getTargetPaths(normalizedType);
       const currentPlatformOptions = getPlatformOptions(normalizedType);
       if (currentPlatformOptions.length === 0) {
         cancel(`No supported platforms found for type '${normalizedType}'.`);
@@ -788,13 +1033,46 @@ async function add(type, url, options) {
         options: currentPlatformOptions,
         required: true
       });
-      if (isCancel(platforms)) {
+      if (isCancel2(platforms)) {
         if (tempDir) await fs4.remove(tempDir);
         if (isSingleShot) break;
         currentType = void 0;
         continue;
       }
       const selectedPlatforms = platforms;
+      const scopeChoice = await chooseInstallScope({ flag: options?.scope });
+      if ("rejected" in scopeChoice) {
+        if (tempDir) await fs4.remove(tempDir);
+        cancel(
+          `Scope --scope=${options?.scope} unavailable: ${scopeChoice.reason}`
+        );
+        process.exit(1);
+        return;
+      }
+      if (scopeChoice.cancelled) {
+        if (tempDir) await fs4.remove(tempDir);
+        if (isSingleShot) break;
+        currentType = void 0;
+        continue;
+      }
+      const { scope: chosenScope, root: scopeRoot } = scopeChoice;
+      const supportedPaths = getTargetPaths(
+        normalizedType,
+        chosenScope,
+        scopeRoot
+      );
+      if (chosenScope === "project") {
+        const proceed = await confirm({
+          message: `Install to project scope at ${pc2.cyan(scopeRoot)}?`,
+          initialValue: true
+        });
+        if (isCancel2(proceed) || !proceed) {
+          if (tempDir) await fs4.remove(tempDir);
+          if (isSingleShot) break;
+          currentType = void 0;
+          continue;
+        }
+      }
       const existingItems = [];
       for (const platform of selectedPlatforms) {
         const targetBase = supportedPaths[platform];
@@ -811,15 +1089,15 @@ async function add(type, url, options) {
       let overwrite = true;
       if (existingItems.length > 0) {
         const limit = 5;
-        const displayList = existingItems.slice(0, limit).map((e) => `${pc.bold(e.item)} (${e.platform})`).join(", ");
+        const displayList = existingItems.slice(0, limit).map((e) => `${pc2.bold(e.item)} (${e.platform})`).join(", ");
         const remainder = existingItems.length - limit;
         const message = remainder > 0 ? `The following items already exist: ${displayList}, and ${remainder} others.` : `The following items already exist: ${displayList}.`;
-        note(message, "Attention");
+        note2(message, "Attention");
         const shouldOverwrite = await confirm({
           message: "Do you want to overwrite existing items?",
           initialValue: false
         });
-        if (isCancel(shouldOverwrite)) {
+        if (isCancel2(shouldOverwrite)) {
           if (tempDir) await fs4.remove(tempDir);
           if (isSingleShot) break;
           currentType = void 0;
@@ -827,8 +1105,8 @@ async function add(type, url, options) {
         }
         overwrite = shouldOverwrite;
       }
-      note(
-        `Installing ${selectedItems.length} ${normalizedType}s to ${selectedPlatforms.length} platforms...`,
+      note2(
+        `Installing ${selectedItems.length} ${normalizedType}s to ${selectedPlatforms.length} platforms (scope: ${chosenScope})...`,
         "Summary"
       );
       const s = spinner();
@@ -840,7 +1118,7 @@ async function add(type, url, options) {
         const targetBase = supportedPaths[platform];
         if (!targetBase) continue;
         for (const item of selectedItems) {
-          const message = `Installing ${pc.bold(item)} to ${pc.cyan(platform)}...`;
+          const message = `Installing ${pc2.bold(item)} to ${pc2.cyan(platform)}...`;
           s.message(message);
           try {
             let currentSourcePath;
@@ -903,17 +1181,17 @@ async function add(type, url, options) {
       }
       if (errors.length > 0) {
         s.stop(
-          pc.yellow(
+          pc2.yellow(
             `Completed with errors. Installed: ${installedCount}, Skipped: ${skippedCount}, Errors: ${errors.length}`
           )
         );
-        console.error(pc.red("\nErrors encountered:"));
+        console.error(pc2.red("\nErrors encountered:"));
         for (const e of errors) {
-          console.error(pc.red(`- ${e}`));
+          console.error(pc2.red(`- ${e}`));
         }
       } else {
         s.stop(
-          pc.green(
+          pc2.green(
             `Successfully installed ${installedCount} ${normalizedType}s. (${skippedCount} skipped)`
           )
         );
@@ -938,21 +1216,21 @@ import {
   cancel as cancel2,
   confirm as confirm2,
   intro as intro2,
-  isCancel as isCancel2,
+  isCancel as isCancel3,
   outro as outro2,
-  select as select2,
+  select as select3,
   spinner as spinner2,
   text
 } from "@clack/prompts";
 import fs5 from "fs-extra";
-import pc2 from "picocolors";
+import pc3 from "picocolors";
 async function importItem(type, url, options) {
   if (!options?.skipIntro) {
-    intro2(pc2.bgCyan(pc2.black(" AI Manager : Import ")));
+    intro2(pc3.bgCyan(pc3.black(" AI Manager : Import ")));
   }
   let currentType = type;
   if (!currentType) {
-    const selectedType = await select2({
+    const selectedType = await select3({
       message: "What would you like to import?",
       options: [
         { label: "Skill", value: "skill" },
@@ -960,7 +1238,7 @@ async function importItem(type, url, options) {
         { label: "Workflow", value: "workflow" }
       ]
     });
-    if (isCancel2(selectedType)) return;
+    if (isCancel3(selectedType)) return;
     currentType = selectedType;
   }
   const normalizedType = currentType.toLowerCase().endsWith("s") ? currentType.slice(0, -1) : currentType;
@@ -981,7 +1259,7 @@ async function importItem(type, url, options) {
           return "Must be a GitHub URL.";
       }
     });
-    if (isCancel2(inputUrl)) return;
+    if (isCancel3(inputUrl)) return;
     currentUrl = inputUrl;
   }
   let tempDir = null;
@@ -996,7 +1274,7 @@ async function importItem(type, url, options) {
       if (!tempDir) throw new Error("Failed to create temp directory");
       itemName = result.skillName;
       isFile = result.isFile;
-      s.stop(pc2.green(`Fetched: ${itemName}`));
+      s.stop(pc3.green(`Fetched: ${itemName}`));
     } catch (e) {
       s.error("Failed to fetch");
       throw e;
@@ -1020,7 +1298,7 @@ async function importItem(type, url, options) {
           message,
           initialValue: false
         });
-        if (isCancel2(shouldOverwrite) || !shouldOverwrite) {
+        if (isCancel3(shouldOverwrite) || !shouldOverwrite) {
           await fs5.remove(tempDir);
           return;
         }
@@ -1030,7 +1308,7 @@ async function importItem(type, url, options) {
         message: `${normalizedType} '${itemName}' already exists in the repo. Overwrite?`,
         initialValue: false
       });
-      if (isCancel2(shouldOverwrite) || !shouldOverwrite) {
+      if (isCancel3(shouldOverwrite) || !shouldOverwrite) {
         await fs5.remove(tempDir);
         return;
       }
@@ -1048,7 +1326,7 @@ async function importItem(type, url, options) {
         await fs5.copy(tempDir, targetPath, { overwrite: true });
       }
     }
-    s.stop(pc2.green(`Successfully imported ${itemName}!`));
+    s.stop(pc3.green(`Successfully imported ${itemName}!`));
     await fs5.remove(tempDir);
     if (!options?.skipIntro) {
       outro2(`${normalizedType} available at: ${targetPath}`);
@@ -1062,82 +1340,135 @@ async function importItem(type, url, options) {
 }
 
 // src/commands/list.ts
-import { intro as intro3, isCancel as isCancel3, outro as outro3, select as select3 } from "@clack/prompts";
+import os5 from "node:os";
+import { cancel as cancel3, intro as intro3, isCancel as isCancel4, outro as outro3, select as select4 } from "@clack/prompts";
 import fs6 from "fs-extra";
-import pc3 from "picocolors";
-async function performListing(type, local) {
-  const normalizedType = type.toLowerCase().endsWith("s") ? type.slice(0, -1) : type.toLowerCase();
-  if (local) {
-    console.log(pc3.bold(pc3.blue(`Installed ${normalizedType}s (Local):`)));
-    const targetPaths = getTargetPaths(normalizedType);
-    let foundAny = false;
-    for (const [platform, pathStr] of Object.entries(targetPaths)) {
-      const fullPath = pathStr;
-      if (await fs6.pathExists(fullPath)) {
-        const entries = await fs6.readdir(fullPath, {
-          withFileTypes: true
-        });
-        const items = [];
-        for (const entry of entries) {
-          if (platform === "codex") {
-            if (await codexEntryMatchesType(fullPath, entry, normalizedType)) {
-              items.push(entry.name);
-            }
-            continue;
-          }
-          if (entry.isDirectory() || entry.isFile() && entry.name.endsWith(".md")) {
-            items.push(entry.name);
-          }
-        }
-        items.sort();
-        if (items.length > 0) {
-          foundAny = true;
-          console.log(pc3.cyan(`  ${platform}:`));
-          for (const item of items) {
-            console.log(`    - ${item}`);
-          }
-        }
+import pc4 from "picocolors";
+async function collectItemsForPlatform(platform, fullPath, normalizedType) {
+  const items = [];
+  const entries = await fs6.readdir(fullPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (platform === "codex") {
+      if (await codexEntryMatchesType(fullPath, entry, normalizedType)) {
+        items.push(entry.name);
       }
+      continue;
     }
-    if (!foundAny) {
-      console.log(pc3.dim(`  No installed ${normalizedType}s found.`));
+    if (entry.isDirectory() || entry.isFile() && entry.name.endsWith(".md")) {
+      items.push(entry.name);
     }
-    console.log("");
-  } else {
-    if (!TYPE_DIRS[normalizedType]) {
-      console.error(
-        pc3.red(
-          `Unknown type: ${type}. Supported types: skill, agent, workflow`
-        )
-      );
-      return;
+  }
+  items.sort();
+  return items;
+}
+function displayPath(absolute, root, scope) {
+  if (scope === "global") return absolute.replace(os5.homedir(), "~");
+  const rel = absolute.startsWith(root) ? `.${absolute.slice(root.length)}` : absolute;
+  return rel;
+}
+async function listLocalForScopes(normalizedType, sections) {
+  console.log(pc4.bold(pc4.blue(`Installed ${normalizedType}s (Local):`)));
+  let foundAny = false;
+  const platformsByOrder = [];
+  for (const section of sections) {
+    for (const platform of Object.keys(section.paths)) {
+      if (!platformsByOrder.includes(platform)) platformsByOrder.push(platform);
     }
-    const dirPath = TYPE_DIRS[normalizedType];
-    if (!await fs6.pathExists(dirPath)) {
-      console.log(
-        pc3.yellow(`No ${normalizedType} directory found at: ${dirPath}`)
+  }
+  for (const platform of platformsByOrder) {
+    let printedHeader = false;
+    for (const section of sections) {
+      const fullPath = section.paths[platform];
+      if (!fullPath) continue;
+      if (!await fs6.pathExists(fullPath)) continue;
+      const items = await collectItemsForPlatform(
+        platform,
+        fullPath,
+        normalizedType
       );
-      return;
-    }
-    const entries = await fs6.readdir(dirPath, { withFileTypes: true });
-    const items = entries.filter(
-      (entry) => entry.isDirectory() || normalizedType !== "skill" && entry.isFile() && entry.name.endsWith(".md")
-    ).map((entry) => entry.name).sort();
-    if (items.length > 0) {
-      console.log(pc3.bold(pc3.blue(`Available ${normalizedType}s:`)));
-      for (const item of items) {
-        console.log(`- ${item}`);
+      if (items.length === 0) continue;
+      foundAny = true;
+      if (!printedHeader) {
+        console.log(pc4.cyan(`  ${platform}:`));
+        printedHeader = true;
       }
-      console.log(pc3.dim(`Total: ${items.length} ${normalizedType}s
-`));
-    } else {
-      console.log(pc3.dim(`No ${normalizedType}s found.`));
+      if (sections.length > 1) {
+        const scopeLabel = section.scope === "global" ? "Global" : "Project";
+        const display = displayPath(fullPath, section.root, section.scope);
+        console.log(pc4.dim(`    ${scopeLabel} (${display}):`));
+        for (const item of items) {
+          console.log(`      - ${item}`);
+        }
+      } else {
+        for (const item of items) {
+          console.log(`    - ${item}`);
+        }
+      }
+    }
+  }
+  if (!foundAny) {
+    console.log(pc4.dim(`  No installed ${normalizedType}s found.`));
+  }
+  console.log("");
+}
+function buildSections(normalizedType, scope, homedir, projectRoot) {
+  const sections = [];
+  if (scope === "global" || scope === "both") {
+    sections.push({
+      scope: "global",
+      root: homedir,
+      paths: getTargetPaths(normalizedType, "global")
+    });
+  }
+  if (scope === "project" || scope === "both") {
+    if (projectRoot) {
+      sections.push({
+        scope: "project",
+        root: projectRoot,
+        paths: getTargetPaths(normalizedType, "project", projectRoot)
+      });
+    }
+  }
+  return sections;
+}
+async function performListing(type, local) {
+  const normalizedType = type.toLowerCase().endsWith("s") ? type.slice(0, -1) : type.toLowerCase();
+  if (local) {
+    throw new Error(
+      "performListing should not be called for local mode; use listLocalForScopes"
+    );
+  }
+  if (!TYPE_DIRS[normalizedType]) {
+    console.error(
+      pc4.red(`Unknown type: ${type}. Supported types: skill, agent, workflow`)
+    );
+    return;
+  }
+  const dirPath = TYPE_DIRS[normalizedType];
+  if (!await fs6.pathExists(dirPath)) {
+    console.log(
+      pc4.yellow(`No ${normalizedType} directory found at: ${dirPath}`)
+    );
+    return;
+  }
+  const entries = await fs6.readdir(dirPath, { withFileTypes: true });
+  const items = entries.filter(
+    (entry) => entry.isDirectory() || normalizedType !== "skill" && entry.isFile() && entry.name.endsWith(".md")
+  ).map((entry) => entry.name).sort();
+  if (items.length > 0) {
+    console.log(pc4.bold(pc4.blue(`Available ${normalizedType}s:`)));
+    for (const item of items) {
+      console.log(`- ${item}`);
     }
+    console.log(pc4.dim(`Total: ${items.length} ${normalizedType}s
+`));
+  } else {
+    console.log(pc4.dim(`No ${normalizedType}s found.`));
   }
 }
 async function list(type, options) {
   if (!options?.skipIntro) {
-    intro3(pc3.bgCyan(pc3.black(" AI Manager : List ")));
+    intro3(pc4.bgCyan(pc4.black(" AI Manager : List ")));
   }
   let currentType = type;
   let isLocal = !!options?.local;
@@ -1145,7 +1476,7 @@ async function list(type, options) {
   try {
     while (true) {
       if (!currentType) {
-        const selected = await select3({
+        const selected = await select4({
           message: `What would you like to list? (View: ${isLocal ? "Local" : "Repository"})`,
           options: [
             { label: "All Skills", value: "skill" },
@@ -1158,7 +1489,7 @@ async function list(type, options) {
             { label: "Exit", value: "exit" }
           ]
         });
-        if (isCancel3(selected) || selected === "exit") {
+        if (isCancel4(selected) || selected === "exit") {
           break;
         }
         if (selected === "toggle") {
@@ -1168,14 +1499,43 @@ async function list(type, options) {
         currentType = selected;
       }
       const typesToList = currentType === "all" ? ["skill", "agent", "workflow"] : [currentType];
-      for (const t of typesToList) {
-        await performListing(t, isLocal);
+      if (isLocal) {
+        const scopeChoice = await chooseListRemoveScope({
+          action: "list",
+          flag: options?.scope
+        });
+        if ("rejected" in scopeChoice) {
+          cancel3(
+            `Scope --scope=${options?.scope} unavailable: ${scopeChoice.reason}`
+          );
+          process.exit(1);
+          return;
+        }
+        if (scopeChoice.cancelled) {
+          if (isSingleShot) break;
+          currentType = void 0;
+          continue;
+        }
+        for (const t of typesToList) {
+          const normalizedType = t.toLowerCase().endsWith("s") ? t.slice(0, -1) : t.toLowerCase();
+          const sections = buildSections(
+            normalizedType,
+            scopeChoice.scope,
+            scopeChoice.homedir,
+            scopeChoice.projectRoot
+          );
+          await listLocalForScopes(normalizedType, sections);
+        }
+      } else {
+        for (const t of typesToList) {
+          await performListing(t, false);
+        }
       }
       if (isSingleShot) break;
       currentType = void 0;
     }
   } catch (error) {
-    console.error(pc3.red("Error listing items:"), error);
+    console.error(pc4.red("Error listing items:"), error);
   }
   if (!options?.skipIntro) {
     outro3("Done!");
@@ -1186,27 +1546,79 @@ async function list(type, options) {
 import path8 from "node:path";
 import {
   autocompleteMultiselect as autocompleteMultiselect2,
+  cancel as cancel4,
   confirm as confirm3,
   intro as intro4,
-  isCancel as isCancel4,
+  isCancel as isCancel5,
   multiselect as multiselect2,
-  note as note2,
+  note as note3,
   outro as outro4,
-  select as select4,
+  select as select5,
   spinner as spinner3
 } from "@clack/prompts";
 import fs7 from "fs-extra";
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 enableAutocompleteMultiSelectShiftAToggle();
+function buildScopedTargetPaths(normalizedType, scope, projectRoot) {
+  const out = [];
+  if (scope === "global" || scope === "both") {
+    out.push({
+      scope: "global",
+      paths: getTargetPaths(normalizedType, "global")
+    });
+  }
+  if ((scope === "project" || scope === "both") && projectRoot) {
+    out.push({
+      scope: "project",
+      paths: getTargetPaths(normalizedType, "project", projectRoot)
+    });
+  }
+  return out;
+}
+async function scanInstalledItems(scopedPaths, normalizedType) {
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  const showScopePrefix = scopedPaths.length > 1;
+  for (const { scope, paths } of scopedPaths) {
+    for (const [platform, pathStr] of Object.entries(paths)) {
+      if (!pathStr) continue;
+      if (!await fs7.pathExists(pathStr)) continue;
+      const entries = await fs7.readdir(pathStr, { withFileTypes: true });
+      for (const entry of entries) {
+        let qualifies = false;
+        if (platform === "codex") {
+          qualifies = await codexEntryMatchesType(
+            pathStr,
+            entry,
+            normalizedType
+          );
+        } else if (entry.isDirectory() || normalizedType === "workflow" && entry.isFile() && entry.name.endsWith(".md") || normalizedType === "agent" && entry.isFile() && entry.name.endsWith(".md")) {
+          qualifies = true;
+        }
+        if (!qualifies) continue;
+        const key = showScopePrefix ? `${scope}:${entry.name}` : entry.name;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        items.push({
+          key,
+          name: entry.name,
+          scope,
+          label: showScopePrefix ? `[${scope}] ${entry.name}` : entry.name
+        });
+      }
+    }
+  }
+  return items.sort((a, b) => a.label.localeCompare(b.label));
+}
 async function remove(type, options) {
   if (!options?.skipIntro) {
-    intro4(pc4.bgCyan(pc4.black(" AI Manager : Remove ")));
+    intro4(pc5.bgCyan(pc5.black(" AI Manager : Remove ")));
   }
   let currentType = type;
   const isSingleShot = !!type;
   while (true) {
     if (!currentType) {
-      const selectedType = await select4({
+      const selectedType = await select5({
         message: "What would you like to remove?",
         options: [
           { label: "Skills", value: "skill" },
@@ -1215,57 +1627,65 @@ async function remove(type, options) {
           { label: "Exit", value: "exit" }
         ]
       });
-      if (isCancel4(selectedType) || selectedType === "exit") {
+      if (isCancel5(selectedType) || selectedType === "exit") {
         break;
       }
       currentType = selectedType;
     }
     const normalizedType = currentType.toLowerCase().endsWith("s") ? currentType.slice(0, -1) : currentType;
-    const targetPaths = getTargetPaths(normalizedType);
-    const uniqueItems = /* @__PURE__ */ new Set();
+    const scopeChoice = await chooseListRemoveScope({
+      action: "remove",
+      flag: options?.scope
+    });
+    if ("rejected" in scopeChoice) {
+      cancel4(
+        `Scope --scope=${options?.scope} unavailable: ${scopeChoice.reason}`
+      );
+      process.exit(1);
+      return;
+    }
+    if (scopeChoice.cancelled) {
+      if (isSingleShot) break;
+      currentType = void 0;
+      continue;
+    }
+    const scopedPaths = buildScopedTargetPaths(
+      normalizedType,
+      scopeChoice.scope,
+      scopeChoice.projectRoot
+    );
     const s = spinner3();
     s.start("Scanning for installed items...");
-    for (const [platform, pathStr] of Object.entries(targetPaths)) {
-      if (await fs7.pathExists(pathStr)) {
-        const entries = await fs7.readdir(pathStr, {
-          withFileTypes: true
-        });
-        for (const entry of entries) {
-          if (platform === "codex") {
-            if (await codexEntryMatchesType(
-              pathStr,
-              entry,
-              normalizedType
-            )) {
-              uniqueItems.add(entry.name);
-            }
-            continue;
-          }
-          if (entry.isDirectory() || normalizedType === "workflow" && entry.isFile() && entry.name.endsWith(".md") || normalizedType === "agent" && entry.isFile() && entry.name.endsWith(".md")) {
-            uniqueItems.add(entry.name);
-          }
-        }
-      }
-    }
-    s.stop(`Found ${uniqueItems.size} unique installed ${normalizedType}s.`);
-    if (uniqueItems.size === 0) {
-      note2(`No installed ${normalizedType}s found.`, "Information");
+    const scannedItems = await scanInstalledItems(scopedPaths, normalizedType);
+    s.stop(`Found ${scannedItems.length} installed ${normalizedType}s.`);
+    if (scannedItems.length === 0) {
+      note3(`No installed ${normalizedType}s found.`, "Information");
       if (isSingleShot) break;
       currentType = void 0;
       continue;
     }
-    const sortedItems = Array.from(uniqueItems).sort();
     const itemSelections = await autocompleteMultiselect2({
       message: `Select ${normalizedType}s to remove:`,
-      options: sortedItems.map((item) => ({ value: item, label: item }))
+      options: scannedItems.map((item) => ({
+        value: item.key,
+        label: item.label
+      }))
     });
-    if (isCancel4(itemSelections)) {
+    if (isCancel5(itemSelections)) {
       if (isSingleShot) break;
       currentType = void 0;
       continue;
     }
-    const selectedItems = itemSelections;
-    const platformOptions = Object.entries(targetPaths).filter(([_, pathStr]) => !!pathStr).map(([platform]) => ({
+    const itemsByKey = new Map(scannedItems.map((i) => [i.key, i]));
+    const selectedScannedItems = itemSelections.map((key) => itemsByKey.get(key)).filter((i) => !!i);
+    const supportedPlatforms = /* @__PURE__ */ new Set();
+    for (const { paths } of scopedPaths) {
+      for (const platform of Object.keys(paths)) {
+        if (paths[platform])
+          supportedPlatforms.add(platform);
+      }
+    }
+    const platformOptions = [...supportedPlatforms].map((platform) => ({
       label: PLATFORM_LABELS[platform],
       value: platform
     }));
@@ -1274,17 +1694,17 @@ async function remove(type, options) {
       options: platformOptions,
       required: true
     });
-    if (isCancel4(platformSelections)) {
+    if (isCancel5(platformSelections)) {
       if (isSingleShot) break;
       currentType = void 0;
       continue;
     }
     const selectedPlatforms = platformSelections;
     const confirmDelete = await confirm3({
-      message: `Are you sure you want to remove ${selectedItems.length} item(s) from ${selectedPlatforms.length} platform(s)?`,
+      message: `Are you sure you want to remove ${selectedScannedItems.length} item(s) from ${selectedPlatforms.length} platform(s)?`,
       initialValue: false
     });
-    if (isCancel4(confirmDelete) || !confirmDelete) {
+    if (isCancel5(confirmDelete) || !confirmDelete) {
       if (isSingleShot) break;
       currentType = void 0;
       continue;
@@ -1294,19 +1714,25 @@ async function remove(type, options) {
     let removedCount = 0;
     let notFoundCount = 0;
     const errors = [];
+    const pathsByScope = /* @__PURE__ */ new Map();
+    for (const { scope, paths } of scopedPaths) {
+      pathsByScope.set(scope, paths);
+    }
     for (const platform of selectedPlatforms) {
-      const targetBase = targetPaths[platform];
-      if (!targetBase) continue;
-      for (const item of selectedItems) {
-        const targetPath = path8.join(targetBase, item);
+      for (const item of selectedScannedItems) {
+        const targetBase = pathsByScope.get(item.scope)?.[platform];
+        if (!targetBase) continue;
+        const targetPath = path8.join(targetBase, item.name);
         if (await fs7.pathExists(targetPath)) {
-          sDel.message(`Removing ${pc4.bold(item)} from ${pc4.cyan(platform)}...`);
+          sDel.message(
+            `Removing ${pc5.bold(item.label)} from ${pc5.cyan(platform)}...`
+          );
           try {
             await fs7.remove(targetPath);
             removedCount++;
           } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            errors.push(`${item} (${platform}): ${msg}`);
+            errors.push(`${item.label} (${platform}): ${msg}`);
           }
         } else {
           notFoundCount++;
@@ -1315,17 +1741,17 @@ async function remove(type, options) {
     }
     if (errors.length > 0) {
       sDel.stop(
-        pc4.yellow(
+        pc5.yellow(
           `Completed with errors. Removed: ${removedCount}, Not Found: ${notFoundCount}, Errors: ${errors.length}`
         )
       );
-      console.error(pc4.red("\nErrors encountered:"));
+      console.error(pc5.red("\nErrors encountered:"));
       for (const e of errors) {
-        console.error(pc4.red(`- ${e}`));
+        console.error(pc5.red(`- ${e}`));
       }
     } else {
       sDel.stop(
-        pc4.green(
+        pc5.green(
           `Successfully removed ${removedCount} items. (${notFoundCount} not found)`
         )
       );
@@ -1341,10 +1767,28 @@ async function remove(type, options) {
 // bin/cli.ts
 var program = new Command();
 program.name("ai-agent").description("CLI to manage AI agents, skills, and workflows").version("1.4.0");
+function parseScopeFlag(value) {
+  if (value === void 0) return void 0;
+  if (isValidScopeFlag(value)) return value;
+  console.error(
+    pc6.red(`Invalid --scope value: ${value}. Expected "global" or "project".`)
+  );
+  process.exit(1);
+}
+function parseListRemoveScopeFlag(value) {
+  if (value === void 0) return void 0;
+  if (isValidListRemoveScopeFlag(value)) return value;
+  console.error(
+    pc6.red(
+      `Invalid --scope value: ${value}. Expected "global", "project", or "both".`
+    )
+  );
+  process.exit(1);
+}
 async function interactiveMain() {
-  intro5(pc5.bgCyan(pc5.black(" AI Manager ")));
+  intro5(pc6.bgCyan(pc6.black(" AI Manager ")));
   while (true) {
-    const action = await select5({
+    const action = await select6({
       message: "What would you like to do?",
       options: [
         { label: "Add Item (Install)", value: "add" },
@@ -1354,7 +1798,7 @@ async function interactiveMain() {
         { label: "Exit", value: "exit" }
       ]
     });
-    if (isCancel5(action) || action === "exit") {
+    if (isCancel6(action) || action === "exit") {
       break;
     }
     switch (action) {
@@ -1374,15 +1818,28 @@ async function interactiveMain() {
   }
   outro5("Goodbye!");
 }
-program.command("list [type]").description("List available items (skills, agents, workflows)").option("-l, --local", "List installed items locally").action(list);
+program.command("list [type]").description("List available items (skills, agents, workflows)").option("-l, --local", "List installed items locally").option(
+  "-s, --scope <scope>",
+  'Scope when listing local installs: "global", "project", or "both"'
+).action(async (type, opts) => {
+  const scope = parseListRemoveScopeFlag(opts?.scope);
+  await list(type, { local: opts?.local, scope });
+});
 program.command("add [type] [url]").description(
   "Add an item (skill, agent, workflow) to platforms (Interactive or from GitHub URL)"
-).action(add);
+).option("-s, --scope <scope>", 'Install scope: "global" or "project"').action(async (type, url, opts) => {
+  const scope = parseScopeFlag(opts?.scope);
+  await add(type, url, { scope });
+});
 program.command("import [type] [url]").description("Import an item from GitHub to the repo").action(async (type, url) => {
   await importItem(type || "", url || "");
 });
-program.command("remove [type]").description("Remove locally installed items (skills, agents, workflows)").action(async (type) => {
-  await remove(type || "");
+program.command("remove [type]").description("Remove locally installed items (skills, agents, workflows)").option(
+  "-s, --scope <scope>",
+  'Scope to remove from: "global", "project", or "both"'
+).action(async (type, opts) => {
+  const scope = parseListRemoveScopeFlag(opts?.scope);
+  await remove(type || "", { scope });
 });
 if (process.argv.length <= 2) {
   await interactiveMain();