aweskill 0.1.5

package/dist/index.js

@@ -0,0 +1,2174 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { homedir as homedir2 } from "os";
+
+// src/lib/backup.ts
+import { access, mkdtemp, mkdir } from "fs/promises";
+import { tmpdir } from "os";
+import path2 from "path";
+import { spawn } from "child_process";
+
+// src/lib/path.ts
+import { homedir } from "os";
+import path from "path";
+function sanitizeName(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 80);
+}
+function getAweskillPaths(homeDir) {
+  const rootDir = path.join(homeDir, ".aweskill");
+  return {
+    homeDir,
+    rootDir,
+    skillsDir: path.join(rootDir, "skills"),
+    dupSkillsDir: path.join(rootDir, "dup_skills"),
+    backupDir: path.join(rootDir, "backup"),
+    bundlesDir: path.join(rootDir, "bundles")
+  };
+}
+function uniqueSorted(items) {
+  return [...new Set(items)].sort();
+}
+function splitCommaValues(input) {
+  return input.split(",").map((value) => value.trim()).filter(Boolean);
+}
+
+// src/lib/backup.ts
+function formatTimestamp(date) {
+  return date.toISOString().replace(/:/g, "-").replace(/\.\d{3}Z$/, "Z");
+}
+async function runTar(args) {
+  await new Promise((resolve, reject) => {
+    const child = spawn("tar", args, { stdio: "ignore" });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`tar exited with code ${code ?? "unknown"}`));
+    });
+  });
+}
+async function createSkillsBackupArchive(homeDir) {
+  const { rootDir, skillsDir, backupDir } = getAweskillPaths(homeDir);
+  await mkdir(backupDir, { recursive: true });
+  const archivePath = await nextBackupArchivePath(backupDir);
+  await runTar(["-czf", archivePath, "-C", rootDir, path2.relative(rootDir, skillsDir)]);
+  return archivePath;
+}
+async function extractSkillsArchive(archivePath) {
+  const tempDir = await mkdtemp(path2.join(tmpdir(), "aweskill-restore-"));
+  await runTar(["-xzf", archivePath, "-C", tempDir]);
+  return {
+    tempDir,
+    extractedSkillsDir: path2.join(tempDir, "skills")
+  };
+}
+async function nextBackupArchivePath(backupDir) {
+  const base = `skills-${formatTimestamp(/* @__PURE__ */ new Date())}`;
+  const primary = path2.join(backupDir, `${base}.tar.gz`);
+  if (!await pathExists(primary)) {
+    return primary;
+  }
+  let index = 1;
+  while (true) {
+    const candidate = path2.join(backupDir, `${base}-${index}.tar.gz`);
+    if (!await pathExists(candidate)) {
+      return candidate;
+    }
+    index += 1;
+  }
+}
+async function pathExists(targetPath) {
+  try {
+    await access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/backup.ts
+async function runBackup(context) {
+  const archivePath = await createSkillsBackupArchive(context.homeDir);
+  context.write(`Backed up skills to ${archivePath}`);
+  return { archivePath };
+}
+
+// src/lib/bundles.ts
+import { access as access3, mkdir as mkdir3, readFile, readdir as readdir2, rm, writeFile } from "fs/promises";
+import path4 from "path";
+import { parse, stringify } from "yaml";
+
+// src/lib/skills.ts
+import { access as access2, mkdir as mkdir2, readdir } from "fs/promises";
+import path3 from "path";
+async function pathExists2(targetPath) {
+  try {
+    await access2(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureHomeLayout(homeDir) {
+  const paths = getAweskillPaths(homeDir);
+  await mkdir2(paths.rootDir, { recursive: true });
+  await mkdir2(paths.skillsDir, { recursive: true });
+  await mkdir2(paths.dupSkillsDir, { recursive: true });
+  await mkdir2(paths.backupDir, { recursive: true });
+  await mkdir2(paths.bundlesDir, { recursive: true });
+}
+function getSkillPath(homeDir, skillName) {
+  return path3.join(getAweskillPaths(homeDir).skillsDir, sanitizeName(skillName));
+}
+async function listSkills(homeDir) {
+  const skillsDir = getAweskillPaths(homeDir).skillsDir;
+  return listSkillEntriesInDirectory(skillsDir);
+}
+async function listSkillEntriesInDirectory(skillsDir) {
+  if (!await pathExists2(skillsDir)) {
+    return [];
+  }
+  const entries = await readdir(skillsDir, { withFileTypes: true });
+  const skills = await Promise.all(
+    entries.filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map(async (entry) => {
+      const skillPath = path3.join(skillsDir, entry.name);
+      return {
+        name: entry.name,
+        path: skillPath,
+        hasSKILLMd: await pathExists2(path3.join(skillPath, "SKILL.md"))
+      };
+    })
+  );
+  return skills.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function assertSkillSource(sourcePath) {
+  const skillReadme = path3.join(sourcePath, "SKILL.md");
+  if (!await pathExists2(skillReadme)) {
+    throw new Error(`Skill source must contain SKILL.md: ${sourcePath}`);
+  }
+}
+async function skillExists(homeDir, skillName) {
+  return pathExists2(getSkillPath(homeDir, skillName));
+}
+
+// src/lib/bundles.ts
+async function pathExists3(targetPath) {
+  try {
+    await access3(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function bundleFilePath(homeDir, bundleName) {
+  return path4.join(getAweskillPaths(homeDir).bundlesDir, `${sanitizeName(bundleName)}.yaml`);
+}
+function bundleFilePathInDirectory(bundlesDir, bundleName) {
+  return path4.join(bundlesDir, `${sanitizeName(bundleName)}.yaml`);
+}
+function normalizeBundle(raw, fallbackName) {
+  const data = raw ?? {};
+  return {
+    name: sanitizeName(data.name ?? fallbackName),
+    skills: uniqueSorted((data.skills ?? []).map((skill) => sanitizeName(String(skill))).filter(Boolean))
+  };
+}
+async function listBundles(homeDir) {
+  const bundlesDir = getAweskillPaths(homeDir).bundlesDir;
+  return listBundlesInDirectory(bundlesDir);
+}
+async function listBundlesInDirectory(bundlesDir) {
+  await mkdir3(bundlesDir, { recursive: true });
+  const entries = await readdir2(bundlesDir, { withFileTypes: true });
+  const bundles = await Promise.all(
+    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".yaml")).map(async (entry) => readBundleFromDirectory(bundlesDir, entry.name.replace(/\.yaml$/, "")))
+  );
+  return bundles.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function readBundle(homeDir, bundleName) {
+  const filePath = bundleFilePath(homeDir, bundleName);
+  const content = await readFile(filePath, "utf8");
+  return normalizeBundle(parse(content), bundleName);
+}
+async function readBundleFromDirectory(bundlesDir, bundleName) {
+  const filePath = bundleFilePathInDirectory(bundlesDir, bundleName);
+  const content = await readFile(filePath, "utf8");
+  return normalizeBundle(parse(content), bundleName);
+}
+async function writeBundle(homeDir, bundle) {
+  const normalized = normalizeBundle(bundle, bundle.name);
+  const filePath = bundleFilePath(homeDir, normalized.name);
+  await mkdir3(path4.dirname(filePath), { recursive: true });
+  await writeFile(filePath, stringify(normalized), "utf8");
+  return normalized;
+}
+async function createBundle(homeDir, bundleName) {
+  const normalizedName = sanitizeName(bundleName);
+  return writeBundle(homeDir, { name: normalizedName, skills: [] });
+}
+async function addSkillToBundle(homeDir, bundleName, skillName) {
+  const normalizedSkill = sanitizeName(skillName);
+  if (!await skillExists(homeDir, normalizedSkill)) {
+    throw new Error(`Unknown skill: ${normalizedSkill}`);
+  }
+  const bundle = await readBundle(homeDir, bundleName);
+  bundle.skills = uniqueSorted([...bundle.skills, normalizedSkill].filter(Boolean));
+  return writeBundle(homeDir, bundle);
+}
+async function removeSkillFromBundle(homeDir, bundleName, skillName) {
+  const bundle = await readBundle(homeDir, bundleName);
+  const normalizedSkill = sanitizeName(skillName);
+  bundle.skills = bundle.skills.filter((skill) => skill !== normalizedSkill);
+  return writeBundle(homeDir, bundle);
+}
+async function deleteBundle(homeDir, bundleName) {
+  const filePath = bundleFilePath(homeDir, bundleName);
+  if (!await pathExists3(filePath)) {
+    return false;
+  }
+  await rm(filePath, { force: true });
+  return true;
+}
+
+// src/lib/templates.ts
+import { access as access4 } from "fs/promises";
+import path5 from "path";
+import { fileURLToPath } from "url";
+async function pathExists4(targetPath) {
+  try {
+    await access4(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getTemplateBundlesDir() {
+  const moduleDir = path5.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path5.resolve(moduleDir, "..", "..", "template", "bundles"),
+    path5.resolve(moduleDir, "..", "template", "bundles")
+  ];
+  for (const candidate of candidates) {
+    if (await pathExists4(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Template bundles directory not found. Checked: ${candidates.join(", ")}`);
+}
+
+// src/commands/bundle.ts
+function parseNames(value) {
+  return uniqueSorted(splitCommaValues(value).map((entry) => sanitizeName(entry)));
+}
+async function runBundleCreate(context, bundleName) {
+  const bundles = await Promise.all(parseNames(bundleName).map((name) => createBundle(context.homeDir, name)));
+  context.write(bundles.map((bundle) => `Created bundle ${bundle.name}`).join("\n"));
+  return bundles;
+}
+async function runBundleShow(context, bundleName) {
+  const bundles = await Promise.all(parseNames(bundleName).map((name) => readBundle(context.homeDir, name)));
+  context.write(bundles.map((bundle) => `${bundle.name}: ${bundle.skills.join(", ") || "(empty)"}`).join("\n"));
+  return bundles;
+}
+async function runBundleAddSkill(context, bundleName, skillName) {
+  const bundleNames = parseNames(bundleName);
+  const skillNames = parseNames(skillName);
+  const bundles = [];
+  for (const currentBundleName of bundleNames) {
+    let bundle = await readBundle(context.homeDir, currentBundleName);
+    for (const currentSkillName of skillNames) {
+      bundle = await addSkillToBundle(context.homeDir, bundle.name, currentSkillName);
+    }
+    bundles.push(bundle);
+  }
+  context.write(bundles.map((bundle) => `Bundle ${bundle.name}: ${bundle.skills.join(", ") || "(empty)"}`).join("\n"));
+  return bundles;
+}
+async function runBundleRemoveSkill(context, bundleName, skillName) {
+  const bundleNames = parseNames(bundleName);
+  const skillNames = parseNames(skillName);
+  const bundles = [];
+  for (const currentBundleName of bundleNames) {
+    let bundle = await readBundle(context.homeDir, currentBundleName);
+    for (const currentSkillName of skillNames) {
+      bundle = await removeSkillFromBundle(context.homeDir, bundle.name, currentSkillName);
+    }
+    bundles.push(bundle);
+  }
+  context.write(bundles.map((bundle) => `Bundle ${bundle.name}: ${bundle.skills.join(", ") || "(empty)"}`).join("\n"));
+  return bundles;
+}
+async function runBundleDelete(context, bundleName) {
+  const deletedNames = [];
+  for (const currentBundleName of parseNames(bundleName)) {
+    const deleted = await deleteBundle(context.homeDir, currentBundleName);
+    if (!deleted) {
+      throw new Error(`Bundle not found: ${currentBundleName}`);
+    }
+    deletedNames.push(currentBundleName);
+  }
+  context.write(deletedNames.map((name) => `Deleted bundle ${name}`).join("\n"));
+  return deletedNames;
+}
+async function runBundleAddTemplate(context, bundleName) {
+  const templateBundlesDir = await getTemplateBundlesDir();
+  const bundles = [];
+  for (const currentBundleName of parseNames(bundleName)) {
+    const templateBundle = await readBundleFromDirectory(templateBundlesDir, currentBundleName);
+    try {
+      await readBundle(context.homeDir, templateBundle.name);
+      throw new Error(`Bundle already exists: ${templateBundle.name}`);
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.includes("ENOENT")) {
+        if (error instanceof Error && error.message.startsWith("Bundle already exists:")) {
+          throw error;
+        }
+        throw error;
+      }
+    }
+    bundles.push(await writeBundle(context.homeDir, templateBundle));
+  }
+  context.write(bundles.map((bundle) => `Added bundle ${bundle.name} from template`).join("\n"));
+  return bundles;
+}
+
+// src/lib/import.ts
+import { access as access5, cp, lstat, mkdir as mkdir4, readlink, readdir as readdir3, rename, rm as rm2, stat } from "fs/promises";
+import path6 from "path";
+var MissingSymlinkSourceError = class extends Error {
+  sourcePath;
+  resolvedSourcePath;
+  constructor(sourcePath, resolvedSourcePath) {
+    super(`Missing symlink source: ${resolvedSourcePath}`);
+    this.name = "MissingSymlinkSourceError";
+    this.sourcePath = sourcePath;
+    this.resolvedSourcePath = resolvedSourcePath;
+  }
+};
+async function pathExists5(targetPath) {
+  try {
+    await access5(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveImportSource(sourcePath) {
+  const statResult = await lstat(sourcePath);
+  if (!statResult.isSymbolicLink()) {
+    return {
+      effectiveSourcePath: sourcePath,
+      isSymlinkSource: false
+    };
+  }
+  const linkTarget = await readlink(sourcePath);
+  const resolvedSourcePath = path6.resolve(path6.dirname(sourcePath), linkTarget);
+  if (!await pathExists5(resolvedSourcePath)) {
+    throw new MissingSymlinkSourceError(sourcePath, resolvedSourcePath);
+  }
+  return {
+    effectiveSourcePath: resolvedSourcePath,
+    isSymlinkSource: true
+  };
+}
+async function mergeMissingEntries(sourcePath, destinationPath) {
+  const sourceStat = await stat(sourcePath);
+  if (sourceStat.isDirectory()) {
+    await mkdir4(destinationPath, { recursive: true });
+    const entries = await readdir3(sourcePath, { withFileTypes: true });
+    for (const entry of entries) {
+      await mergeMissingEntries(path6.join(sourcePath, entry.name), path6.join(destinationPath, entry.name));
+    }
+    return;
+  }
+  if (await pathExists5(destinationPath)) {
+    return;
+  }
+  await mkdir4(path6.dirname(destinationPath), { recursive: true });
+  await cp(sourcePath, destinationPath, { recursive: false, errorOnExist: true, force: false });
+}
+async function copyIntoDestination(sourcePath, destination, override) {
+  if (!override && await pathExists5(destination)) {
+    await mergeMissingEntries(sourcePath, destination);
+    return;
+  }
+  await cp(sourcePath, destination, { recursive: true, errorOnExist: false, force: override });
+}
+async function moveIntoDestination(sourcePath, destination, override) {
+  if (!await pathExists5(destination)) {
+    await rename(sourcePath, destination);
+    return;
+  }
+  if (override) {
+    await cp(sourcePath, destination, { recursive: true, errorOnExist: false, force: true });
+    await rm2(sourcePath, { recursive: true, force: true });
+    return;
+  }
+  await mergeMissingEntries(sourcePath, destination);
+}
+async function importBatchSources(options) {
+  const seen = /* @__PURE__ */ new Set();
+  const imported = [];
+  const skipped = [];
+  const overwritten = [];
+  const warnings = [];
+  const errors = [];
+  let missingSources = 0;
+  for (const source of options.sources) {
+    if (seen.has(source.name)) {
+      skipped.push(source.name);
+      continue;
+    }
+    seen.add(source.name);
+    const alreadyExists = await skillExists(options.homeDir, source.name);
+    if (alreadyExists && !options.override) {
+      skipped.push(source.name);
+      continue;
+    }
+    try {
+      const result = await importSkill({
+        homeDir: options.homeDir,
+        sourcePath: source.path,
+        mode: options.mode,
+        override: options.override
+      });
+      warnings.push(...result.warnings);
+      if (alreadyExists) {
+        overwritten.push(source.name);
+      } else {
+        imported.push(source.name);
+      }
+    } catch (error) {
+      if (error instanceof MissingSymlinkSourceError) {
+        missingSources += 1;
+        errors.push(`Broken symlink for ${source.name}: ${source.path}; source not found: ${error.resolvedSourcePath}`);
+        continue;
+      }
+      if (error instanceof Error && error.message.startsWith("Skill source must contain SKILL.md:")) {
+        skipped.push(source.name);
+        continue;
+      }
+      throw error;
+    }
+  }
+  return { imported, skipped, overwritten, warnings, errors, missingSources };
+}
+async function listImportableChildren(sourceRoot) {
+  const entries = await readdir3(sourceRoot, { withFileTypes: true });
+  const sources = [];
+  for (const entry of entries) {
+    if (!(entry.isDirectory() || entry.isSymbolicLink())) {
+      continue;
+    }
+    const childPath = path6.join(sourceRoot, entry.name);
+    if (await pathExists5(path6.join(childPath, "SKILL.md"))) {
+      sources.push({
+        name: sanitizeName(entry.name),
+        path: childPath
+      });
+      continue;
+    }
+    if (entry.isSymbolicLink()) {
+      sources.push({
+        name: sanitizeName(entry.name),
+        path: childPath
+      });
+    }
+  }
+  return sources.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function importSkill(options) {
+  const { effectiveSourcePath, isSymlinkSource } = await resolveImportSource(options.sourcePath);
+  await assertSkillSource(effectiveSourcePath);
+  const skillName = sanitizeName(path6.basename(options.sourcePath));
+  if (!skillName) {
+    throw new Error(`Unable to infer skill name from path: ${options.sourcePath}`);
+  }
+  const destination = getSkillPath(options.homeDir, skillName);
+  await mkdir4(path6.dirname(destination), { recursive: true });
+  const warnings = [];
+  if (isSymlinkSource) {
+    warnings.push(`Source ${options.sourcePath} is a symlink; copied from ${effectiveSourcePath} to ${destination}`);
+  }
+  if (options.mode === "mv" && !isSymlinkSource) {
+    await moveIntoDestination(effectiveSourcePath, destination, options.override ?? false);
+  } else {
+    await copyIntoDestination(effectiveSourcePath, destination, options.override ?? false);
+  }
+  return { name: skillName, destination, warnings };
+}
+async function importScannedSkills(options) {
+  return importBatchSources({
+    homeDir: options.homeDir,
+    sources: options.candidates.map((candidate) => ({
+      name: candidate.name,
+      path: candidate.path
+    })),
+    mode: options.mode,
+    override: options.override
+  });
+}
+async function importPath(options) {
+  if (await pathExists5(path6.join(options.sourcePath, "SKILL.md"))) {
+    const skillName = sanitizeName(path6.basename(options.sourcePath));
+    const alreadyExisted = skillName ? await skillExists(options.homeDir, skillName) : false;
+    if (alreadyExisted && !options.override) {
+      return {
+        kind: "single",
+        alreadyExisted: true,
+        name: skillName,
+        destination: getSkillPath(options.homeDir, skillName),
+        warnings: []
+      };
+    }
+    const result = await importSkill(options);
+    return { kind: "single", alreadyExisted, ...result };
+  }
+  const sources = await listImportableChildren(options.sourcePath);
+  if (sources.length === 0) {
+    throw new Error(`Path is neither a skill directory nor a skills directory: ${options.sourcePath}`);
+  }
+  const batchResult = await importBatchSources({
+    homeDir: options.homeDir,
+    sources,
+    mode: options.mode,
+    override: options.override
+  });
+  return { kind: "batch", ...batchResult };
+}
+
+// src/lib/scanner.ts
+import { access as access7, lstat as lstat2, readdir as readdir4, readlink as readlink2 } from "fs/promises";
+import path8 from "path";
+
+// src/lib/agents.ts
+import { access as access6 } from "fs/promises";
+import path7 from "path";
+var AGENTS = {
+  amp: {
+    id: "amp",
+    displayName: "Amp",
+    defaultProjectionMode: "symlink",
+    rootDir: (homeDir) => path7.join(homeDir, ".amp"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".amp", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".amp", "skills")
+  },
+  "claude-code": {
+    id: "claude-code",
+    displayName: "Claude Code",
+    defaultProjectionMode: "symlink",
+    rootDir: (homeDir) => path7.join(homeDir, ".claude"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".claude", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".claude", "skills")
+  },
+  cline: {
+    id: "cline",
+    displayName: "Cline",
+    defaultProjectionMode: "symlink",
+    rootDir: (homeDir) => path7.join(homeDir, ".cline"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".cline", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".cline", "skills")
+  },
+  codex: {
+    id: "codex",
+    displayName: "Codex",
+    defaultProjectionMode: "symlink",
+    rootDir: (homeDir) => path7.join(homeDir, ".codex"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".codex", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".codex", "skills")
+  },
+  cursor: {
+    id: "cursor",
+    displayName: "Cursor",
+    defaultProjectionMode: "copy",
+    rootDir: (homeDir) => path7.join(homeDir, ".cursor"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".cursor", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".cursor", "skills")
+  },
+  "gemini-cli": {
+    id: "gemini-cli",
+    displayName: "Gemini CLI",
+    defaultProjectionMode: "symlink",
+    rootDir: (homeDir) => path7.join(homeDir, ".gemini"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".gemini", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".gemini", "skills")
+  },
+  goose: {
+    id: "goose",
+    displayName: "Goose",
+    defaultProjectionMode: "symlink",
+    rootDir: (homeDir) => path7.join(homeDir, ".goose"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".goose", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".goose", "skills")
+  },
+  opencode: {
+    id: "opencode",
+    displayName: "OpenCode",
+    defaultProjectionMode: "symlink",
+    rootDir: (homeDir) => path7.join(homeDir, ".opencode"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".opencode", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".opencode", "skills")
+  },
+  roo: {
+    id: "roo",
+    displayName: "Roo Code",
+    defaultProjectionMode: "symlink",
+    rootDir: (homeDir) => path7.join(homeDir, ".roo"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".roo", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".roo", "skills")
+  },
+  windsurf: {
+    id: "windsurf",
+    displayName: "Windsurf",
+    defaultProjectionMode: "symlink",
+    rootDir: (homeDir) => path7.join(homeDir, ".windsurf"),
+    globalSkillsDir: (homeDir) => path7.join(homeDir, ".windsurf", "skills"),
+    projectSkillsDir: (projectDir) => path7.join(projectDir, ".windsurf", "skills")
+  }
+};
+async function pathExists6(targetPath) {
+  try {
+    await access6(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listSupportedAgents() {
+  return Object.values(AGENTS);
+}
+function listSupportedAgentIds() {
+  return listSupportedAgents().map((agent) => agent.id).sort();
+}
+function isAgentId(value) {
+  return value in AGENTS;
+}
+function getAgentDefinition(agentId) {
+  return AGENTS[agentId];
+}
+function resolveAgentSkillsDir(agentId, scope, baseDir) {
+  const definition = getAgentDefinition(agentId);
+  return scope === "global" ? definition.globalSkillsDir(baseDir) : definition.projectSkillsDir(baseDir);
+}
+function getProjectionMode(agentId) {
+  return getAgentDefinition(agentId).defaultProjectionMode;
+}
+async function detectInstalledAgents(options) {
+  const installed = [];
+  for (const agent of listSupportedAgents()) {
+    const globalRootPath = agent.rootDir(options.homeDir);
+    const projectPath = options.projectDir ? agent.projectSkillsDir(options.projectDir) : null;
+    if (await pathExists6(globalRootPath)) {
+      installed.push(agent.id);
+      continue;
+    }
+    if (projectPath && await pathExists6(projectPath)) {
+      installed.push(agent.id);
+    }
+  }
+  return installed.sort();
+}
+
+// src/lib/scanner.ts
+async function hasSkillReadme(skillDir) {
+  try {
+    await access7(path8.join(skillDir, "SKILL.md"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isSymlinkPath(targetPath) {
+  try {
+    return (await lstat2(targetPath)).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function pathExists7(targetPath) {
+  try {
+    await access7(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveSymlinkSource(targetPath) {
+  try {
+    const linkTarget = await readlink2(targetPath);
+    const sourcePath = path8.resolve(path8.dirname(targetPath), linkTarget);
+    return {
+      sourcePath,
+      isBroken: !await pathExists7(sourcePath)
+    };
+  } catch {
+    return {
+      isBroken: true
+    };
+  }
+}
+async function scanDirectory(baseDir, agentId, scope, projectDir) {
+  try {
+    const entries = await readdir4(baseDir, { withFileTypes: true });
+    const candidates = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) {
+        continue;
+      }
+      const fullPath = path8.join(baseDir, entry.name);
+      const isSymlink = await isSymlinkPath(fullPath);
+      const symlinkInfo = isSymlink ? await resolveSymlinkSource(fullPath) : { isBroken: false };
+      if (!await hasSkillReadme(fullPath) && !symlinkInfo.isBroken) {
+        continue;
+      }
+      candidates.push({
+        agentId,
+        name: sanitizeName(entry.name),
+        path: fullPath,
+        scope,
+        projectDir,
+        isSymlink,
+        symlinkSourcePath: symlinkInfo.sourcePath,
+        isBrokenSymlink: symlinkInfo.isBroken
+      });
+    }
+    return candidates;
+  } catch {
+    return [];
+  }
+}
+async function scanSkills(options) {
+  const results = [];
+  for (const agent of listSupportedAgents()) {
+    results.push(...await scanDirectory(agent.globalSkillsDir(options.homeDir), agent.id, "global"));
+    for (const projectDir of options.projectDirs ?? []) {
+      results.push(...await scanDirectory(agent.projectSkillsDir(projectDir), agent.id, "project", projectDir));
+    }
+  }
+  return results.sort((left, right) => left.path.localeCompare(right.path));
+}
+
+// src/commands/import.ts
+async function runImport(context, options) {
+  if (options.scan) {
+    const candidates = await scanSkills({
+      homeDir: context.homeDir,
+      projectDirs: [context.cwd]
+    });
+    const result2 = await importScannedSkills({
+      homeDir: context.homeDir,
+      candidates,
+      mode: options.mode,
+      override: options.override
+    });
+    for (const warning of result2.warnings) {
+      context.write(`Warning: ${warning}`);
+    }
+    for (const error of result2.errors) {
+      context.error(`Error: ${error}`);
+    }
+    context.write(`Imported ${result2.imported.length} skills`);
+    if (result2.overwritten.length > 0) {
+      context.write(`Overwritten ${result2.overwritten.length} existing skills: ${result2.overwritten.join(", ")}`);
+    }
+    if (result2.skipped.length > 0) {
+      context.write(`Skipped ${result2.skipped.length} existing skills (use --override to overwrite): ${result2.skipped.join(", ")}`);
+    }
+    if (result2.missingSources > 0) {
+      context.write(`Missing source files: ${result2.missingSources}`);
+    }
+    return result2;
+  }
+  if (!options.sourcePath) {
+    throw new Error("import requires a source path or --scan");
+  }
+  const result = await importPath({
+    homeDir: context.homeDir,
+    sourcePath: options.sourcePath,
+    mode: options.mode,
+    override: options.override
+  });
+  if (result.kind === "single") {
+    for (const warning of result.warnings) {
+      context.write(`Warning: ${warning}`);
+    }
+    if (result.alreadyExisted && !options.override) {
+      context.write(`Skipped ${result.name} (already exists; use --override to overwrite)`);
+    } else if (result.alreadyExisted) {
+      context.write(`Overwritten ${result.name}`);
+    } else {
+      context.write(`Imported ${result.name}`);
+    }
+    return result;
+  }
+  for (const warning of result.warnings) {
+    context.write(`Warning: ${warning}`);
+  }
+  for (const error of result.errors) {
+    context.error(`Error: ${error}`);
+  }
+  context.write(`Imported ${result.imported.length} skills`);
+  if (result.overwritten.length > 0) {
+    context.write(`Overwritten ${result.overwritten.length} existing skills: ${result.overwritten.join(", ")}`);
+  }
+  if (result.skipped.length > 0) {
+    context.write(`Skipped ${result.skipped.length} existing skills (use --override to overwrite): ${result.skipped.join(", ")}`);
+  }
+  if (result.missingSources > 0) {
+    context.write(`Missing source files: ${result.missingSources}`);
+  }
+  return result;
+}
+
+// src/lib/symlink.ts
+import { cp as cp2, lstat as lstat3, mkdir as mkdir5, readFile as readFile2, readdir as readdir5, readlink as readlink3, rm as rm3, symlink, unlink, writeFile as writeFile2 } from "fs/promises";
+import path9 from "path";
+var COPY_MARKER = ".aweskill-projection.json";
+async function tryLstat(targetPath) {
+  try {
+    return await lstat3(targetPath);
+  } catch {
+    return null;
+  }
+}
+async function readCopyMarker(targetPath) {
+  try {
+    const content = await readFile2(path9.join(targetPath, COPY_MARKER), "utf8");
+    const parsed = JSON.parse(content);
+    return parsed.managedBy === "aweskill" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function assertProjectionTargetSafe(mode, sourcePath, targetPath, options = {}) {
+  const existing = await tryLstat(targetPath);
+  if (!existing) {
+    return;
+  }
+  if (mode === "symlink") {
+    if (!existing.isSymbolicLink()) {
+      if (options.allowReplaceExisting) {
+        return;
+      }
+      throw new Error(`Refusing to overwrite non-symlink target: ${targetPath}`);
+    }
+    const currentTarget = await readlink3(targetPath);
+    const resolvedCurrent = path9.resolve(path9.dirname(targetPath), currentTarget);
+    if (resolvedCurrent === path9.resolve(sourcePath)) {
+      return;
+    }
+    return;
+  }
+  if (existing.isSymbolicLink()) {
+    return;
+  }
+  const marker = await readCopyMarker(targetPath);
+  if (!marker) {
+    if (options.allowReplaceExisting) {
+      return;
+    }
+    throw new Error(`Refusing to overwrite unmanaged directory: ${targetPath}`);
+  }
+}
+async function createSkillSymlink(sourcePath, targetPath, options = {}) {
+  await mkdir5(path9.dirname(targetPath), { recursive: true });
+  const existing = await tryLstat(targetPath);
+  if (existing?.isSymbolicLink()) {
+    const currentTarget = await readlink3(targetPath);
+    const resolvedCurrent = path9.resolve(path9.dirname(targetPath), currentTarget);
+    if (resolvedCurrent === path9.resolve(sourcePath)) {
+      return "skipped";
+    }
+    await unlink(targetPath);
+  } else if (existing) {
+    if (options.allowReplaceExisting) {
+      await rm3(targetPath, { force: true, recursive: true });
+    } else {
+      throw new Error(`Refusing to overwrite non-symlink target: ${targetPath}`);
+    }
+  }
+  const linkTarget = path9.relative(path9.dirname(targetPath), sourcePath) || ".";
+  await symlink(linkTarget, targetPath, "dir");
+  return "created";
+}
+async function createSkillCopy(sourcePath, targetPath, options = {}) {
+  await mkdir5(path9.dirname(targetPath), { recursive: true });
+  const existing = await tryLstat(targetPath);
+  if (existing?.isSymbolicLink()) {
+    await unlink(targetPath);
+  } else if (existing) {
+    const marker2 = await readCopyMarker(targetPath);
+    if (!marker2) {
+      if (!options.allowReplaceExisting) {
+        throw new Error(`Refusing to overwrite unmanaged directory: ${targetPath}`);
+      }
+    }
+    await rm3(targetPath, { force: true, recursive: true });
+  }
+  await cp2(sourcePath, targetPath, { recursive: true });
+  const marker = { managedBy: "aweskill", sourcePath: path9.resolve(sourcePath) };
+  await writeFile2(path9.join(targetPath, COPY_MARKER), JSON.stringify(marker, null, 2), "utf8");
+  return "created";
+}
+async function removeManagedProjection(targetPath) {
+  const existing = await tryLstat(targetPath);
+  if (!existing) {
+    return false;
+  }
+  if (existing.isSymbolicLink()) {
+    await unlink(targetPath);
+    return true;
+  }
+  if (existing.isDirectory()) {
+    const marker = await readCopyMarker(targetPath);
+    if (marker) {
+      await rm3(targetPath, { force: true, recursive: true });
+      return true;
+    }
+  }
+  return false;
+}
+async function listManagedSkillNames(skillsDir, centralSkillsDir) {
+  const result = /* @__PURE__ */ new Map();
+  try {
+    const entries = await readdir5(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const targetPath = path9.join(skillsDir, entry.name);
+      if (entry.isSymbolicLink()) {
+        try {
+          const currentTarget = await readlink3(targetPath);
+          const resolvedCurrent = path9.resolve(path9.dirname(targetPath), currentTarget);
+          if (resolvedCurrent.startsWith(path9.resolve(centralSkillsDir))) {
+            result.set(entry.name, "symlink");
+          }
+        } catch {
+          result.set(entry.name, "symlink");
+        }
+        continue;
+      }
+      if (entry.isDirectory()) {
+        const marker = await readCopyMarker(targetPath);
+        if (marker) {
+          result.set(entry.name, "copy");
+        }
+      }
+    }
+  } catch {
+    return result;
+  }
+  return result;
+}
+
+// src/commands/check.ts
+var DEFAULT_PREVIEW_COUNT = 5;
+function getProjectDir(context, explicitProjectDir) {
+  return explicitProjectDir ?? context.cwd;
+}
+async function resolveAgentsForScope(context, requestedAgents, scope, projectDir) {
+  if (requestedAgents.length === 0 || requestedAgents.includes("all")) {
+    const detected = await detectInstalledAgents({
+      homeDir: context.homeDir,
+      projectDir: scope === "project" ? projectDir : void 0
+    });
+    return detected.length > 0 ? detected : listSupportedAgentIds();
+  }
+  return uniqueSorted(
+    requestedAgents.map((agent) => {
+      if (!isAgentId(agent)) {
+        throw new Error(`Unsupported agent: ${agent}`);
+      }
+      return agent;
+    })
+  );
+}
+function formatSkillBlockWithSummary(title, skills, verbose = false) {
+  if (skills.length === 0) {
+    return [`No skills found for ${title.replace(/:$/, "").toLowerCase()}.`];
+  }
+  const lines = [title];
+  const categories = [
+    { title: "  linked", marker: "\u2713", key: "linked" },
+    { title: "  duplicate", marker: "!", key: "duplicate" },
+    { title: "  new", marker: "+", key: "new" }
+  ];
+  for (const category of categories) {
+    const entries = skills.filter((skill) => skill.category === category.key);
+    lines.push(`${category.title}: ${entries.length}`);
+    const preview = verbose ? entries : entries.slice(0, DEFAULT_PREVIEW_COUNT);
+    for (const skill of preview) {
+      lines.push(`    ${category.marker} ${skill.name} ${skill.path}`);
+    }
+    if (!verbose && entries.length > preview.length) {
+      lines.push(`    ... and ${entries.length - preview.length} more (use --verbose to show all)`);
+    }
+  }
+  return lines;
+}
+async function runCheck(context, options) {
+  const lines = [];
+  const centralSkillEntries = await listSkills(context.homeDir);
+  const centralSkills = new Set(centralSkillEntries.map((skill) => skill.name));
+  const projectDir = options.scope === "project" ? getProjectDir(context, options.projectDir) : void 0;
+  const agents = await resolveAgentsForScope(context, options.agents, options.scope, projectDir);
+  const updated = [];
+  const skipped = [];
+  let importedCount = 0;
+  for (const agentId of agents) {
+    const baseDir = options.scope === "global" ? context.homeDir : projectDir;
+    const skillsDir = resolveAgentSkillsDir(agentId, options.scope, baseDir);
+    const managed = await listManagedSkillNames(skillsDir, getAweskillPaths(context.homeDir).skillsDir);
+    const skills = await listSkillEntriesInDirectory(skillsDir);
+    const checked = skills.map((skill) => {
+      let category = "new";
+      if (managed.has(skill.name)) {
+        category = "linked";
+      } else if (centralSkills.has(skill.name)) {
+        category = "duplicate";
+      }
+      return {
+        name: skill.name,
+        path: skill.path,
+        category,
+        hasSKILLMd: skill.hasSKILLMd
+      };
+    });
+    if (options.update) {
+      for (const skill of checked) {
+        if (skill.category === "linked") {
+          continue;
+        }
+        if (!skill.hasSKILLMd) {
+          context.write(`Warning: Skipping ${agentId}:${skill.name}; missing SKILL.md in ${skill.path}`);
+          skipped.push(`${agentId}:${skill.name}`);
+          continue;
+        }
+        if (skill.category === "new") {
+          await importSkill({
+            homeDir: context.homeDir,
+            sourcePath: skill.path,
+            mode: "mv"
+          });
+          centralSkills.add(skill.name);
+          importedCount += 1;
+        }
+        await createSkillSymlink(getSkillPath(context.homeDir, skill.name), skill.path, {
+          allowReplaceExisting: true
+        });
+        updated.push(`${agentId}:${skill.name}`);
+      }
+    }
+    const title = options.scope === "global" ? `Global skills for ${agentId}:` : `Project skills for ${agentId} (${projectDir}):`;
+    lines.push("");
+    lines.push(...formatSkillBlockWithSummary(title, checked, options.verbose));
+  }
+  if (options.update) {
+    lines.push("");
+    lines.push(`Updated ${updated.length} skills`);
+    if (importedCount > 0) {
+      lines.push(`Imported ${importedCount} new skills into the central repo`);
+    }
+    if (skipped.length > 0) {
+      lines.push(`Skipped ${skipped.length} entries: ${skipped.join(", ")}`);
+    }
+  }
+  context.write(lines.join("\n").trim());
+  return { agents, updated, importedCount, skipped };
+}
+
+// src/commands/disable.ts
+function getProjectDir2(context, explicitProjectDir) {
+  return explicitProjectDir ?? context.cwd;
+}
+async function resolveAgentsForScope2(context, requestedAgents, scope, projectDir) {
+  if (requestedAgents.length === 0 || requestedAgents.includes("all")) {
+    const detected = await detectInstalledAgents({
+      homeDir: context.homeDir,
+      projectDir: scope === "project" ? projectDir : void 0
+    });
+    return detected.length > 0 ? detected : listSupportedAgentIds();
+  }
+  return uniqueSorted(
+    requestedAgents.map((agent) => {
+      if (!isAgentId(agent)) {
+        throw new Error(`Unsupported agent: ${agent}`);
+      }
+      return agent;
+    })
+  );
+}
+async function resolveSkillNames(context, type, names) {
+  const normalizedNames = uniqueSorted(splitCommaValues(names).map((name) => sanitizeName(name)));
+  if (normalizedNames.includes("all")) {
+    if (type === "bundle") {
+      const bundles = await listBundles(context.homeDir);
+      return uniqueSorted(bundles.flatMap((bundle) => bundle.skills));
+    }
+    const { skillsDir: centralSkillsDir } = getAweskillPaths(context.homeDir);
+    const detected = await detectInstalledAgents({
+      homeDir: context.homeDir
+    });
+    const globalManaged = await Promise.all(
+      detected.map(async (agentId) => {
+        const agentSkillsDir = resolveAgentSkillsDir(agentId, "global", context.homeDir);
+        return listManagedSkillNames(agentSkillsDir, centralSkillsDir);
+      })
+    );
+    const managedSkillNames = uniqueSorted(
+      globalManaged.flatMap((managed) => [...managed.keys()])
+    );
+    return managedSkillNames;
+  }
+  if (type === "bundle") {
+    const bundles = await Promise.all(normalizedNames.map((bundleName) => readBundle(context.homeDir, bundleName)));
+    return uniqueSorted(bundles.flatMap((bundle) => bundle.skills));
+  }
+  const resolvedNames = [];
+  for (const normalizedName of normalizedNames) {
+    if (!await skillExists(context.homeDir, normalizedName)) {
+      resolvedNames.push(normalizedName);
+      continue;
+    }
+    resolvedNames.push(normalizedName);
+  }
+  return uniqueSorted(resolvedNames);
+}
+async function bundlesWithCoEnabledSiblings(options) {
+  const { skillsDir: centralSkillsDir } = getAweskillPaths(options.homeDir);
+  const bundles = await listBundles(options.homeDir);
+  const normalized = sanitizeName(options.skillName);
+  const hit = /* @__PURE__ */ new Set();
+  for (const bundle of bundles) {
+    if (!bundle.skills.includes(normalized)) {
+      continue;
+    }
+    const siblings = bundle.skills.filter((s) => s !== normalized);
+    if (siblings.length === 0) {
+      continue;
+    }
+    for (const agentId of options.agents) {
+      const agentSkillsDir = resolveAgentSkillsDir(agentId, options.scope, options.baseDir);
+      const managed = await listManagedSkillNames(agentSkillsDir, centralSkillsDir);
+      if (siblings.some((s) => managed.has(s))) {
+        hit.add(bundle.name);
+        break;
+      }
+    }
+  }
+  return [...hit].sort();
+}
+async function runDisable(context, options) {
+  const projectDir = options.scope === "project" ? getProjectDir2(context, options.projectDir) : void 0;
+  const agents = await resolveAgentsForScope2(context, options.agents, options.scope, projectDir);
+  const baseDir = options.scope === "global" ? context.homeDir : projectDir ?? context.cwd;
+  const skillNames = await resolveSkillNames(context, options.type, options.name);
+  if (splitCommaValues(options.name).map((name) => sanitizeName(name)).includes("all") && options.type === "skill") {
+    const { skillsDir: centralSkillsDir } = getAweskillPaths(context.homeDir);
+    const scopedManaged = await Promise.all(
+      agents.map(async (agentId) => {
+        const agentSkillsDir = resolveAgentSkillsDir(agentId, options.scope, baseDir);
+        return listManagedSkillNames(agentSkillsDir, centralSkillsDir);
+      })
+    );
+    const managedSkillNames = uniqueSorted(
+      scopedManaged.flatMap((managed) => [...managed.keys()])
+    );
+    skillNames.splice(0, skillNames.length, ...managedSkillNames);
+  }
+  if (options.type === "skill" && skillNames.length === 1 && !options.force) {
+    const bundleNames = await bundlesWithCoEnabledSiblings({
+      homeDir: context.homeDir,
+      skillName: skillNames[0],
+      agents,
+      scope: options.scope,
+      baseDir
+    });
+    if (bundleNames.length > 0) {
+      throw new Error(
+        `Skill "${skillNames[0]}" is listed in bundle(s): ${bundleNames.join(", ")}. Other skills from those bundle(s) are still enabled in this scope. Use --force to remove only this skill's projection, or run "aweskill agent remove bundle <name>" to drop the whole bundle.`
+      );
+    }
+  }
+  const removed = [];
+  for (const agentId of agents) {
+    const skillsDir = resolveAgentSkillsDir(agentId, options.scope, baseDir);
+    for (const skillName of skillNames) {
+      const targetPath = `${skillsDir}/${skillName}`;
+      const wasRemoved = await removeManagedProjection(targetPath);
+      if (wasRemoved) {
+        removed.push(`${agentId}:${skillName}`);
+      }
+    }
+  }
+  const scopeLabel = options.scope === "global" ? "global scope" : projectDir ?? context.cwd;
+  const targetLabel = uniqueSorted(splitCommaValues(options.name).map((name) => sanitizeName(name))).join(", ");
+  context.write(`Disabled ${options.type} ${targetLabel} for ${agents.join(", ")} in ${scopeLabel}${removed.length > 0 ? ` (${removed.length} removed)` : ""}`);
+  return { agents, skillNames, removed };
+}
+
+// src/commands/enable.ts
+import { mkdir as mkdir6 } from "fs/promises";
+function getProjectDir3(context, explicitProjectDir) {
+  return explicitProjectDir ?? context.cwd;
+}
+async function resolveAgentsForScope3(context, requestedAgents, scope, projectDir) {
+  if (requestedAgents.length === 0 || requestedAgents.includes("all")) {
+    const detected = await detectInstalledAgents({
+      homeDir: context.homeDir,
+      projectDir: scope === "project" ? projectDir : void 0
+    });
+    return detected.length > 0 ? detected : listSupportedAgentIds();
+  }
+  return uniqueSorted(
+    requestedAgents.map((agent) => {
+      if (!isAgentId(agent)) {
+        throw new Error(`Unsupported agent: ${agent}`);
+      }
+      return agent;
+    })
+  );
+}
+async function resolveSkillNames2(context, type, names) {
+  const normalizedNames = uniqueSorted(splitCommaValues(names).map((name) => sanitizeName(name)));
+  if (normalizedNames.includes("all")) {
+    if (type === "bundle") {
+      const bundles = await listBundles(context.homeDir);
+      const skillNames = uniqueSorted(bundles.flatMap((bundle) => bundle.skills));
+      for (const skillName of skillNames) {
+        if (!await skillExists(context.homeDir, skillName)) {
+          throw new Error(`A bundle in "all" references unknown skill: ${skillName}`);
+        }
+      }
+      return skillNames;
+    }
+    const skills = await listSkills(context.homeDir);
+    return skills.map((skill) => skill.name);
+  }
+  if (type === "bundle") {
+    const bundles = await Promise.all(normalizedNames.map((bundleName) => readBundle(context.homeDir, bundleName)));
+    const skillNames = uniqueSorted(bundles.flatMap((bundle) => bundle.skills));
+    for (const skillName of skillNames) {
+      if (!await skillExists(context.homeDir, skillName)) {
+        const bundle = bundles.find((candidate) => candidate.skills.includes(skillName));
+        throw new Error(`Bundle ${bundle?.name ?? "(unknown)"} references unknown skill: ${skillName}`);
+      }
+    }
+    return skillNames;
+  }
+  for (const normalizedName of normalizedNames) {
+    if (!await skillExists(context.homeDir, normalizedName)) {
+      throw new Error(`Unknown skill: ${normalizedName}`);
+    }
+  }
+  return normalizedNames;
+}
+async function runEnable(context, options) {
+  const projectDir = options.scope === "project" ? getProjectDir3(context, options.projectDir) : void 0;
+  const agents = await resolveAgentsForScope3(context, options.agents, options.scope, projectDir);
+  const skillNames = await resolveSkillNames2(context, options.type, options.name);
+  const baseDir = options.scope === "global" ? context.homeDir : projectDir ?? context.cwd;
+  for (const agentId of agents) {
+    const skillsDir = resolveAgentSkillsDir(agentId, options.scope, baseDir);
+    await mkdir6(skillsDir, { recursive: true });
+    for (const skillName of skillNames) {
+      const sourcePath = getSkillPath(context.homeDir, skillName);
+      const targetPath = `${skillsDir}/${skillName}`;
+      await assertProjectionTargetSafe(getProjectionMode(agentId), sourcePath, targetPath);
+    }
+  }
+  const created = [];
+  for (const agentId of agents) {
+    const skillsDir = resolveAgentSkillsDir(agentId, options.scope, baseDir);
+    const mode = getProjectionMode(agentId);
+    for (const skillName of skillNames) {
+      const sourcePath = getSkillPath(context.homeDir, skillName);
+      const targetPath = `${skillsDir}/${skillName}`;
+      const result = mode === "symlink" ? await createSkillSymlink(sourcePath, targetPath) : await createSkillCopy(sourcePath, targetPath);
+      if (result === "created") {
+        created.push(`${agentId}:${skillName}`);
+      }
+    }
+  }
+  const scopeLabel = options.scope === "global" ? "global scope" : projectDir ?? context.cwd;
+  const targetLabel = uniqueSorted(splitCommaValues(options.name).map((name) => sanitizeName(name))).join(", ");
+  context.write(`Enabled ${options.type} ${targetLabel} for ${agents.join(", ")} in ${scopeLabel}${created.length > 0 ? ` (${created.length} created)` : ""}`);
+  return { agents, skillNames, created };
+}
+
+// src/commands/scan.ts
+function groupLabel(candidate) {
+  return candidate.scope === "global" ? `Global scanned skills for ${candidate.agentId}:` : `Project scanned skills for ${candidate.agentId} (${candidate.projectDir}):`;
+}
+function formatScanSummary(candidates, verbose = false) {
+  if (candidates.length === 0) {
+    return "(no scanned skills)";
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = `${candidate.scope}:${candidate.agentId}:${candidate.projectDir ?? ""}`;
+    const bucket = groups.get(key) ?? [];
+    bucket.push(candidate);
+    groups.set(key, bucket);
+  }
+  const lines = ["Scanned skills:"];
+  for (const [, groupedCandidates] of [...groups.entries()].sort((left, right) => left[0].localeCompare(right[0]))) {
+    const sorted = [...groupedCandidates].sort((left, right) => left.name.localeCompare(right.name));
+    lines.push(`  ${groupLabel(sorted[0])} ${sorted.length}`);
+    if (verbose) {
+      for (const candidate of sorted) {
+        lines.push(`    \u2713 ${candidate.name} ${candidate.path}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+async function runScan(context, options) {
+  const candidates = await scanSkills({
+    homeDir: context.homeDir,
+    projectDirs: [context.cwd]
+  });
+  context.write(formatScanSummary(candidates, options.verbose));
+  if (options.add) {
+    const result = await importScannedSkills({
+      homeDir: context.homeDir,
+      candidates,
+      mode: options.mode ?? "cp",
+      override: options.override
+    });
+    for (const warning of result.warnings) {
+      context.write(`Warning: ${warning}`);
+    }
+    for (const error of result.errors) {
+      context.error(`Error: ${error}`);
+    }
+    context.write(`Imported ${result.imported.length} skills`);
+    if (result.overwritten.length > 0) {
+      context.write(`Overwritten ${result.overwritten.length} existing skills: ${result.overwritten.join(", ")}`);
+    }
+    if (result.skipped.length > 0) {
+      context.write(`Skipped ${result.skipped.length} existing skills (use --override to overwrite): ${result.skipped.join(", ")}`);
+    }
+    if (result.missingSources > 0) {
+      context.write(`Missing source files: ${result.missingSources}`);
+    }
+    return { candidates, ...result };
+  }
+  return candidates;
+}
+
+// src/commands/init.ts
+async function runInit(context, options) {
+  await ensureHomeLayout(context.homeDir);
+  context.write(`Initialized ${context.homeDir}/.aweskill`);
+  if (options.scan) {
+    const candidates = await scanSkills({ homeDir: context.homeDir, projectDirs: [context.cwd] });
+    context.write(formatScanSummary(candidates, options.verbose));
+    return candidates;
+  }
+  return [];
+}
+
+// src/commands/list.ts
+var DEFAULT_PREVIEW_COUNT2 = 5;
+async function runListSkills(context, options = {}) {
+  const skills = await listSkills(context.homeDir);
+  if (skills.length === 0) {
+    context.write("No skills found in central repo.");
+    return skills;
+  }
+  const preview = options.verbose ? skills : skills.slice(0, DEFAULT_PREVIEW_COUNT2);
+  const lines = [`Skills in central repo: ${skills.length} total`];
+  if (!options.verbose && skills.length > preview.length) {
+    lines.push(`Showing first ${preview.length} skills (use --verbose to show all)`);
+  }
+  for (const skill of preview) {
+    const marker = skill.hasSKILLMd ? "\u2713" : "!";
+    lines.push(`  ${marker} ${skill.name} ${skill.path}`);
+  }
+  context.write(lines.join("\n"));
+  return skills;
+}
+function formatBundleLines(title, bundles, verbose) {
+  if (bundles.length === 0) {
+    return [title, "(none)"];
+  }
+  const preview = verbose ? bundles : bundles.slice(0, DEFAULT_PREVIEW_COUNT2);
+  const lines = [`${title}: ${bundles.length} total`];
+  if (!verbose && bundles.length > preview.length) {
+    lines.push(`Showing first ${preview.length} bundles (use --verbose to show all)`);
+  }
+  for (const bundle of preview) {
+    const skillsPreview = verbose ? bundle.skills : bundle.skills.slice(0, DEFAULT_PREVIEW_COUNT2);
+    const suffix = !verbose && bundle.skills.length > skillsPreview.length ? `, ... (+${bundle.skills.length - skillsPreview.length} more)` : "";
+    lines.push(`  - ${bundle.name}: ${bundle.skills.length} skills${skillsPreview.length > 0 ? ` -> ${skillsPreview.join(", ")}${suffix}` : " -> (empty)"}`);
+  }
+  return lines;
+}
+async function runListBundles(context, options = {}) {
+  const bundles = await listBundles(context.homeDir);
+  context.write(formatBundleLines("Bundles in central repo", bundles, options.verbose).join("\n"));
+  return bundles;
+}
+async function runListTemplateBundles(context, options = {}) {
+  const templateBundlesDir = await getTemplateBundlesDir();
+  const bundles = await listBundlesInDirectory(templateBundlesDir);
+  context.write(formatBundleLines("Bundle templates", bundles, options.verbose).join("\n"));
+  return bundles;
+}
+
+// src/commands/recover.ts
+import { cp as cp3, mkdir as mkdir7, readlink as readlink4, unlink as unlink2 } from "fs/promises";
+import path10 from "path";
+function getProjectDir4(context, explicitProjectDir) {
+  return explicitProjectDir ?? context.cwd;
+}
+async function resolveAgentsForScope4(context, requestedAgents, scope, projectDir) {
+  if (requestedAgents.length === 0 || requestedAgents.includes("all")) {
+    const detected = await detectInstalledAgents({
+      homeDir: context.homeDir,
+      projectDir: scope === "project" ? projectDir : void 0
+    });
+    return detected.length > 0 ? detected : listSupportedAgentIds();
+  }
+  return uniqueSorted(
+    requestedAgents.map((agent) => {
+      if (!isAgentId(agent)) {
+        throw new Error(`Unsupported agent: ${agent}`);
+      }
+      return agent;
+    })
+  );
+}
+async function runRecover(context, options) {
+  const projectDir = options.scope === "project" ? getProjectDir4(context, options.projectDir) : void 0;
+  const agents = await resolveAgentsForScope4(context, options.agents, options.scope, projectDir);
+  const { skillsDir: centralSkillsDir } = getAweskillPaths(context.homeDir);
+  const baseDir = options.scope === "global" ? context.homeDir : projectDir ?? context.cwd;
+  const recovered = [];
+  for (const agentId of agents) {
+    const agentSkillsDir = resolveAgentSkillsDir(agentId, options.scope, baseDir);
+    const managed = await listManagedSkillNames(agentSkillsDir, centralSkillsDir);
+    for (const [skillName, mode] of managed) {
+      if (mode !== "symlink") {
+        continue;
+      }
+      const targetPath = path10.join(agentSkillsDir, skillName);
+      const sourcePath = path10.join(centralSkillsDir, skillName);
+      const currentTarget = await readlink4(targetPath);
+      const resolvedCurrent = path10.resolve(path10.dirname(targetPath), currentTarget);
+      if (resolvedCurrent !== path10.resolve(sourcePath)) {
+        continue;
+      }
+      await unlink2(targetPath);
+      await mkdir7(path10.dirname(targetPath), { recursive: true });
+      await cp3(sourcePath, targetPath, { recursive: true });
+      recovered.push(`${agentId}:${skillName}`);
+    }
+  }
+  const scopeLabel = options.scope === "global" ? "global scope" : projectDir ?? context.cwd;
+  context.write(`Recovered ${recovered.length} skill projection(s) in ${scopeLabel}${recovered.length > 0 ? `: ${recovered.join(", ")}` : ""}`);
+  return { agents, recovered };
+}
+
+// src/lib/references.ts
+import { rm as rm4 } from "fs/promises";
+import path11 from "path";
+async function findSkillReferences(options) {
+  const normalizedSkill = sanitizeName(options.skillName);
+  const { skillsDir } = getAweskillPaths(options.homeDir);
+  const bundles = (await listBundles(options.homeDir)).filter((bundle) => bundle.skills.includes(normalizedSkill)).map((bundle) => bundle.name);
+  const agentProjections = [];
+  const baseDirs = [
+    { scope: "global", dir: options.homeDir }
+  ];
+  if (options.projectDir) {
+    baseDirs.push({ scope: "project", dir: options.projectDir });
+  }
+  for (const { scope, dir } of baseDirs) {
+    for (const agent of listSupportedAgents()) {
+      const agentSkillsDir = resolveAgentSkillsDir(agent.id, scope, dir);
+      const managed = await listManagedSkillNames(agentSkillsDir, skillsDir);
+      if (managed.has(normalizedSkill)) {
+        agentProjections.push(`${agent.id}(${scope}):${normalizedSkill}`);
+      }
+    }
+  }
+  return { bundles, agentProjections };
+}
+async function removeSkillWithReferences(options) {
+  const normalizedSkill = sanitizeName(options.skillName);
+  const { skillsDir } = getAweskillPaths(options.homeDir);
+  const bundles = await listBundles(options.homeDir);
+  for (const bundle of bundles) {
+    if (!bundle.skills.includes(normalizedSkill)) {
+      continue;
+    }
+    bundle.skills = bundle.skills.filter((skill) => skill !== normalizedSkill);
+    await writeBundle(options.homeDir, bundle);
+  }
+  const baseDirs = [
+    { scope: "global", dir: options.homeDir }
+  ];
+  if (options.projectDir) {
+    baseDirs.push({ scope: "project", dir: options.projectDir });
+  }
+  for (const { scope, dir } of baseDirs) {
+    for (const agent of listSupportedAgents()) {
+      const agentSkillsDir = resolveAgentSkillsDir(agent.id, scope, dir);
+      const managed = await listManagedSkillNames(agentSkillsDir, skillsDir);
+      if (managed.has(normalizedSkill)) {
+        await removeManagedProjection(path11.join(agentSkillsDir, normalizedSkill));
+      }
+    }
+  }
+  await rm4(getSkillPath(options.homeDir, normalizedSkill), { force: true, recursive: true });
+}
+
+// src/commands/remove.ts
+async function runRemove(context, options) {
+  const projectDir = options.projectDir ?? context.cwd;
+  const references = await findSkillReferences({
+    homeDir: context.homeDir,
+    skillName: options.skillName,
+    projectDir
+  });
+  const referenceCount = references.bundles.length + references.agentProjections.length;
+  if (referenceCount > 0 && !options.force) {
+    throw new Error(
+      `Skill ${options.skillName} is still referenced: ${[
+        ...references.bundles,
+        ...references.agentProjections
+      ].join(", ")}`
+    );
+  }
+  await removeSkillWithReferences({
+    homeDir: context.homeDir,
+    skillName: options.skillName,
+    projectDir
+  });
+  context.write(`Removed ${options.skillName}`);
+  return references;
+}
+
+// src/commands/restore.ts
+import { cp as cp4, mkdir as mkdir8, rm as rm5 } from "fs/promises";
+import path12 from "path";
+async function runRestore(context, options) {
+  const { tempDir, extractedSkillsDir } = await extractSkillsArchive(options.archivePath);
+  try {
+    const extracted = await listSkillEntriesInDirectory(extractedSkillsDir);
+    if (extracted.length === 0) {
+      throw new Error(`Archive does not contain a skills/ directory: ${options.archivePath}`);
+    }
+    const { skillsDir } = getAweskillPaths(context.homeDir);
+    const current = await listSkillEntriesInDirectory(skillsDir);
+    const currentNames = new Set(current.map((entry) => entry.name));
+    const conflicts = extracted.map((entry) => entry.name).filter((name) => currentNames.has(name));
+    if (conflicts.length > 0 && !options.override) {
+      throw new Error(`Restore would overwrite existing skills: ${conflicts.join(", ")}. Use --override to replace them.`);
+    }
+    const backupArchivePath = await createSkillsBackupArchive(context.homeDir);
+    if (options.override) {
+      await rm5(skillsDir, { recursive: true, force: true });
+      await mkdir8(path12.dirname(skillsDir), { recursive: true });
+      await cp4(extractedSkillsDir, skillsDir, { recursive: true });
+    } else {
+      await mkdir8(skillsDir, { recursive: true });
+      for (const entry of extracted) {
+        await cp4(entry.path, path12.join(skillsDir, entry.name), { recursive: true });
+      }
+    }
+    context.write(`Restored ${extracted.length} skills from ${options.archivePath}`);
+    context.write(`Backed up current skills to ${backupArchivePath}`);
+    return { restored: extracted.map((entry) => entry.name), backupArchivePath };
+  } finally {
+    await rm5(tempDir, { recursive: true, force: true });
+  }
+}
+
+// src/lib/rmdup.ts
+import { mkdir as mkdir9, readdir as readdir7, rename as rename2, rm as rm6 } from "fs/promises";
+import path13 from "path";
+var NUMERIC_SUFFIX_PATTERN = /^(.*?)-(\d+(?:\.\d+)*)$/;
+function parseSkillName(name) {
+  const match = name.match(NUMERIC_SUFFIX_PATTERN);
+  if (!match) {
+    return {
+      baseName: name,
+      hasNumericSuffix: false
+    };
+  }
+  return {
+    baseName: match[1],
+    hasNumericSuffix: true,
+    numericKey: match[2].split(".").map((part) => Number.parseInt(part, 10))
+  };
+}
+function compareNumericKeys(left, right) {
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftValue = left[index] ?? 0;
+    const rightValue = right[index] ?? 0;
+    if (leftValue !== rightValue) {
+      return leftValue - rightValue;
+    }
+  }
+  return 0;
+}
+function choosePreferredSkill(entries) {
+  return [...entries].sort((left, right) => {
+    const leftParsed = parseSkillName(left.name);
+    const rightParsed = parseSkillName(right.name);
+    if (leftParsed.hasNumericSuffix && !rightParsed.hasNumericSuffix) {
+      return -1;
+    }
+    if (!leftParsed.hasNumericSuffix && rightParsed.hasNumericSuffix) {
+      return 1;
+    }
+    if (leftParsed.numericKey && rightParsed.numericKey) {
+      const comparison = compareNumericKeys(rightParsed.numericKey, leftParsed.numericKey);
+      if (comparison !== 0) {
+        return comparison;
+      }
+    }
+    return left.name.localeCompare(right.name);
+  })[0];
+}
+async function findDuplicateSkills(homeDir) {
+  const skills = await listSkills(homeDir);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const parsed = parseSkillName(skill.name);
+    const bucket = grouped.get(parsed.baseName) ?? [];
+    bucket.push(skill);
+    grouped.set(parsed.baseName, bucket);
+  }
+  const duplicates = [];
+  for (const [baseName, entries] of grouped) {
+    if (entries.length < 2) {
+      continue;
+    }
+    const kept = choosePreferredSkill(entries);
+    const removed = entries.filter((entry) => entry.path !== kept.path).sort((left, right) => left.name.localeCompare(right.name));
+    if (removed.length > 0) {
+      duplicates.push({ baseName, kept, removed });
+    }
+  }
+  return duplicates.sort((left, right) => left.baseName.localeCompare(right.baseName));
+}
+async function removeDuplicateSkills(homeDir, duplicates, options = {}) {
+  const paths = getAweskillPaths(homeDir);
+  await mkdir9(paths.dupSkillsDir, { recursive: true });
+  const moved = [];
+  const deleted = [];
+  for (const group of duplicates) {
+    for (const skill of group.removed) {
+      if (options.delete) {
+        await rm6(skill.path, { recursive: true, force: true });
+        deleted.push(skill.name);
+        continue;
+      }
+      const targetPath = await nextAvailableDupPath(paths.dupSkillsDir, skill.name);
+      await rename2(skill.path, targetPath);
+      moved.push(`${skill.name} -> ${targetPath}`);
+    }
+  }
+  return { moved, deleted };
+}
+async function nextAvailableDupPath(dupSkillsDir, skillName) {
+  const entries = new Set(await readdir7(dupSkillsDir).catch(() => []));
+  if (!entries.has(skillName)) {
+    return path13.join(dupSkillsDir, skillName);
+  }
+  let index = 1;
+  while (entries.has(`${skillName}-${index}`)) {
+    index += 1;
+  }
+  return path13.join(dupSkillsDir, `${skillName}-${index}`);
+}
+
+// src/commands/rmdup.ts
+async function runRmdup(context, options) {
+  if (options.delete && !options.remove) {
+    throw new Error("--delete requires --remove");
+  }
+  const duplicates = await findDuplicateSkills(context.homeDir);
+  if (duplicates.length === 0) {
+    context.write("No duplicate skills found in the central repo.");
+    return { duplicates, moved: [], deleted: [] };
+  }
+  const lines = ["Duplicate skill groups in central repo:"];
+  for (const group of duplicates) {
+    lines.push(`  ${group.baseName}: ${group.removed.length + 1} entries`);
+    lines.push(`    keep: ${group.kept.name} ${group.kept.path}`);
+    for (const skill of group.removed) {
+      lines.push(`    drop: ${skill.name} ${skill.path}`);
+    }
+  }
+  let moved = [];
+  let deleted = [];
+  if (options.remove) {
+    const result = await removeDuplicateSkills(context.homeDir, duplicates, { delete: options.delete });
+    moved = result.moved;
+    deleted = result.deleted;
+    lines.push("");
+    if (options.delete) {
+      lines.push(`Deleted ${deleted.length} duplicate skills`);
+    } else {
+      lines.push(`Moved ${moved.length} duplicate skills to ${context.homeDir}/.aweskill/dup_skills`);
+    }
+  } else {
+    lines.push("");
+    lines.push("Dry run only. Use --remove to move duplicates into dup_skills, or --remove --delete to delete them.");
+  }
+  context.write(lines.join("\n"));
+  return { duplicates, moved, deleted };
+}
+
+// src/commands/sync.ts
+import { access as access8 } from "fs/promises";
+import path14 from "path";
+async function pathExists8(targetPath) {
+  try {
+    await access8(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runSync(context, options) {
+  const { skillsDir } = getAweskillPaths(context.homeDir);
+  const baseDirs = /* @__PURE__ */ new Set();
+  baseDirs.add({ scope: "global", dir: context.homeDir });
+  if (options.projectDir) {
+    baseDirs.add({ scope: "project", dir: options.projectDir });
+  }
+  if (await pathExists8(path14.join(context.cwd, ".aweskill.yaml"))) {
+    baseDirs.add({ scope: "project", dir: context.cwd });
+  }
+  let removed = 0;
+  const warnings = [];
+  for (const { scope, dir } of baseDirs) {
+    for (const agent of listSupportedAgents()) {
+      const skillsDir2 = resolveAgentSkillsDir(agent.id, scope, dir);
+      const managed = await listManagedSkillNames(skillsDir2, skillsDir);
+      for (const [skillName] of managed) {
+        const sourcePath = path14.join(skillsDir, skillName);
+        if (!await pathExists8(sourcePath)) {
+          const wasRemoved = await removeManagedProjection(path14.join(skillsDir2, skillName));
+          if (wasRemoved) {
+            removed += 1;
+            warnings.push(`Removed stale projection: ${agent.id}:${skillName} (source missing)`);
+          }
+        }
+      }
+    }
+  }
+  context.write(`Sync complete. Removed ${removed} stale projection(s).`);
+  if (warnings.length > 0) {
+    context.write(warnings.join("\n"));
+  }
+  return { removed, warnings };
+}
+
+// src/lib/runtime.ts
+import { realpathSync } from "fs";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+function isDirectCliEntry(importMetaUrl, argv1) {
+  if (!argv1) {
+    return false;
+  }
+  try {
+    const executedPath = realpathSync(argv1);
+    const modulePath = realpathSync(fileURLToPath2(importMetaUrl));
+    return pathToFileURL(modulePath).href === pathToFileURL(executedPath).href;
+  } catch {
+    return importMetaUrl === pathToFileURL(argv1).href;
+  }
+}
+
+// src/lib/ui.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+function emitMessage(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return;
+  }
+  if (trimmed.startsWith("Warning: ")) {
+    p.log.warn(trimmed.slice("Warning: ".length));
+    return;
+  }
+  if (trimmed.startsWith("Error: ")) {
+    p.log.error(trimmed.slice("Error: ".length));
+    return;
+  }
+  if (trimmed.startsWith("Created ") || trimmed.startsWith("Backed up ") || trimmed.startsWith("Imported ") || trimmed.startsWith("Enabled ") || trimmed.startsWith("Disabled ") || trimmed.startsWith("Initialized ") || trimmed.startsWith("Deleted ") || trimmed.startsWith("Removed ") || trimmed.startsWith("Recovered ") || trimmed.startsWith("Sync applied ")) {
+    p.log.success(trimmed);
+    return;
+  }
+  if (trimmed.startsWith("Skills in central repo:") || trimmed === "Scanned skills:" || trimmed === "Duplicate skill groups in central repo:" || trimmed === "Bundles:" || trimmed.startsWith("Global skills for ") || trimmed.startsWith("Project skills for ")) {
+    console.log(pc.bold(trimmed));
+    return;
+  }
+  if (trimmed.startsWith("linked:") || trimmed.startsWith("duplicate:") || trimmed.startsWith("new:")) {
+    console.log(pc.dim(trimmed));
+    return;
+  }
+  if (trimmed.startsWith("No duplicate skills found")) {
+    console.log(pc.dim(trimmed));
+    return;
+  }
+  if (line.startsWith("  Global scanned skills for ") || line.startsWith("  Project scanned skills for ")) {
+    console.log(pc.dim(line.trim()));
+    return;
+  }
+  if (line.startsWith("    keep: ") || line.startsWith("    drop: ")) {
+    const [label, ...rest] = line.trim().split(" ");
+    const marker = label === "keep:" ? pc.green("keep:") : pc.yellow("drop:");
+    console.log(`    ${marker} ${rest.join(" ")}`);
+    return;
+  }
+  if (line.startsWith("  \u2713 ")) {
+    const rest = line.slice(4);
+    const firstSpace = rest.indexOf(" ");
+    if (firstSpace === -1) {
+      console.log(`  ${pc.green("\u2713")} ${pc.cyan(rest)}`);
+      return;
+    }
+    const name = rest.slice(0, firstSpace);
+    const location = rest.slice(firstSpace + 1);
+    console.log(`  ${pc.green("\u2713")} ${pc.cyan(name)} ${pc.dim(location)}`);
+    return;
+  }
+  if (line.startsWith("  ! ")) {
+    const rest = line.slice(4);
+    const firstSpace = rest.indexOf(" ");
+    if (firstSpace === -1) {
+      console.log(`  ${pc.yellow("!")} ${pc.cyan(rest)}`);
+      return;
+    }
+    const name = rest.slice(0, firstSpace);
+    const location = rest.slice(firstSpace + 1);
+    console.log(`  ${pc.yellow("!")} ${pc.cyan(name)} ${pc.dim(location)}`);
+    return;
+  }
+  if (line.startsWith("    \u2713 ") || line.startsWith("    ! ") || line.startsWith("    + ")) {
+    const marker = line.slice(4, 5);
+    const rest = line.slice(6);
+    const firstSpace = rest.indexOf(" ");
+    const name = firstSpace === -1 ? rest : rest.slice(0, firstSpace);
+    const location = firstSpace === -1 ? "" : rest.slice(firstSpace + 1);
+    const coloredMarker = marker === "\u2713" ? pc.green("\u2713") : marker === "!" ? pc.yellow("!") : pc.cyan("+");
+    console.log(`    ${coloredMarker} ${pc.cyan(name)}${location ? ` ${pc.dim(location)}` : ""}`);
+    return;
+  }
+  if (trimmed.startsWith("No skills found ") || trimmed === "No bundles found." || trimmed.startsWith("Showing first ") || trimmed.startsWith("... and ")) {
+    console.log(pc.dim(trimmed));
+    return;
+  }
+  p.log.message(trimmed, { symbol: pc.cyan("\u2022") });
+}
+function commandTitle(title) {
+  return pc.bgCyan(pc.black(` ${title} `));
+}
+function writeCliMessage(message) {
+  for (const line of message.split("\n")) {
+    emitMessage(line);
+  }
+}
+function writeCliError(message) {
+  for (const line of message.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    p.log.error(line.replace(/^Error:\s*/, ""));
+  }
+}
+function introCommand(title) {
+  p.intro(commandTitle(title));
+}
+function outroCommand(message = pc.green("Done.")) {
+  p.outro(message);
+}
+
+// src/index.ts
+function createRuntimeContext(overrides = {}) {
+  return {
+    cwd: overrides.cwd ?? process.cwd(),
+    homeDir: overrides.homeDir ?? process.env.AWESKILL_HOME ?? homedir2(),
+    write: overrides.write ?? writeCliMessage,
+    error: overrides.error ?? writeCliError
+  };
+}
+async function runFramedCommand(title, action) {
+  introCommand(title);
+  const result = await action();
+  outroCommand();
+  return result;
+}
+function collectAgents(value, previous) {
+  return [...previous ?? [], ...value.split(",").map((entry) => entry.trim()).filter(Boolean)];
+}
+function getMode(value) {
+  if (value === "mv" || value === "cp") {
+    return value;
+  }
+  throw new Error(`Unsupported import mode: ${value}. Use "cp" or "mv".`);
+}
+function getActivationType(value) {
+  if (value === "bundle" || value === "skill") {
+    return value;
+  }
+  throw new Error(`Unsupported activation type: ${value}`);
+}
+function formatCliErrorMessage(message) {
+  const match = message.match(/missing required argument '([^']+)'/i);
+  if (!match) {
+    const optionMatch = message.match(/option '([^']+)' argument missing/i);
+    if (optionMatch?.[1] === "--agent <agent>") {
+      return 'Option --agent <agent> argument missing. Use one or more supported agent ids, for example "codex" or "codex,cursor". Run "aweskill agent supported" to see the supported agent list.';
+    }
+    const normalizedMessage = message.replace(/^error:\s*/i, "");
+    const bundleFileMatch = normalizedMessage.match(/ENOENT: no such file or directory, open '([^']+\/bundles\/([^/'"]+)\.ya?ml)'/i);
+    if (bundleFileMatch) {
+      const bundleName = bundleFileMatch[2];
+      if (bundleFileMatch[1]?.includes("/template/bundles/")) {
+        return `Bundle template not found: ${bundleName}. Run "aweskill bundle template list" to see available bundle templates.`;
+      }
+      return `Bundle not found: ${bundleName}. Run "aweskill bundle list" to see available bundles.`;
+    }
+    const unknownSkillMatch = normalizedMessage.match(/^Unknown skill: (.+)$/);
+    if (unknownSkillMatch) {
+      return `Unknown skill: ${unknownSkillMatch[1]}. Run "aweskill skill list" to see available skills.`;
+    }
+    const bundleNotFoundMatch = normalizedMessage.match(/^Bundle not found: (.+)$/);
+    if (bundleNotFoundMatch) {
+      return `Bundle not found: ${bundleNotFoundMatch[1]}. Run "aweskill bundle list" to see available bundles.`;
+    }
+    return normalizedMessage;
+  }
+  const argName = match[1];
+  const hints = {
+    archive: 'Use a backup archive path, for example "skills-2026-04-12T19-20-00Z.tar.gz".',
+    bundle: "Use a bundle name.",
+    name: 'Use a bundle or skill name, for example "my-bundle", "biopython", or "all".',
+    skill: "Use a skill name.",
+    type: 'Use "bundle" or "skill".'
+  };
+  const hint = hints[argName];
+  return `Missing required argument <${argName}>.${hint ? ` ${hint}` : ""}`;
+}
+function writeSupportedAgents(context) {
+  const lines = [
+    "Supported agents:",
+    "amp (Amp)",
+    "claude-code (Claude Code)",
+    "cline (Cline)",
+    "codex (Codex)",
+    "cursor (Cursor)",
+    "gemini-cli (Gemini CLI)",
+    "goose (Goose)",
+    "opencode (OpenCode)",
+    "roo (Roo Code)",
+    "windsurf (Windsurf)"
+  ];
+  for (const line of lines) {
+    context.write(line);
+  }
+}
+function configureCommandTree(command) {
+  command.showHelpAfterError();
+  command.exitOverride((error) => {
+    throw new Error(formatCliErrorMessage(error.message));
+  });
+  for (const child of command.commands) {
+    configureCommandTree(child);
+  }
+}
+function createProgram(overrides = {}) {
+  const context = createRuntimeContext(overrides);
+  const program = new Command();
+  program.name("aweskill").description("Local skill orchestration CLI for AI agents").version("0.1.5").helpOption("-h, --help", "Display help");
+  const skill = program.command("skill").description("Manage skills in the central store");
+  skill.command("list").description("List skills in the central store").option("--verbose", "show all skills instead of a short preview", false).action(async (options) => {
+    await runListSkills(context, { verbose: options.verbose });
+  });
+  skill.command("scan").description("Scan supported agent skill directories").option("--verbose", "show scanned skill details instead of per-agent totals", false).action(async (options) => {
+    await runFramedCommand(
+      " aweskill skill scan ",
+      async () => runScan(context, {
+        verbose: options.verbose
+      })
+    );
+  });
+  skill.command("import").argument("[path]").description("Import one skill or a skills root directory").option("--scan", "import scanned skills", false).option("--mode <mode>", "import mode: cp (default) or mv", getMode, "cp").option("--override", "overwrite existing files when importing", false).action(async (sourcePath, options) => {
+    await runFramedCommand(
+      " aweskill skill import ",
+      async () => runImport(context, {
+        sourcePath,
+        scan: options.scan,
+        mode: options.mode,
+        override: options.override
+      })
+    );
+  });
+  skill.command("remove").argument("<skill>").description("Remove a skill from the central store").option("--force", "remove and clean references", false).option("--project <dir>", "project config to inspect").action(async (skillName, options) => {
+    await runFramedCommand(
+      " aweskill skill remove ",
+      async () => runRemove(context, {
+        skillName,
+        force: options.force,
+        projectDir: options.project
+      })
+    );
+  });
+  const bundle = program.command("bundle").description("Manage skill bundles");
+  bundle.command("list").description("List bundles in the central store").option("--verbose", "show all bundles instead of a short preview", false).action(async (options) => {
+    await runListBundles(context, { verbose: options.verbose });
+  });
+  bundle.command("create").argument("<name>").description("Create a bundle").action(async (name) => {
+    await runFramedCommand(" aweskill bundle create ", async () => runBundleCreate(context, name));
+  });
+  bundle.command("show").argument("<name>").description("Show bundle contents").action(async (name) => {
+    await runBundleShow(context, name);
+  });
+  bundle.command("add").argument("<bundle>").argument("<skill>").description("Add skill entries to one or more bundles").action(async (bundleName, skillName) => {
+    await runFramedCommand(" aweskill bundle add ", async () => runBundleAddSkill(context, bundleName, skillName));
+  });
+  bundle.command("remove").argument("<bundle>").argument("<skill>").description("Remove skill entries from one or more bundles").action(async (bundleName, skillName) => {
+    await runFramedCommand(" aweskill bundle remove ", async () => runBundleRemoveSkill(context, bundleName, skillName));
+  });
+  bundle.command("delete").argument("<name>").description("Delete a bundle").action(async (name) => {
+    await runFramedCommand(" aweskill bundle delete ", async () => runBundleDelete(context, name));
+  });
+  const bundleTemplate = bundle.command("template").description("Manage built-in bundle templates");
+  bundleTemplate.command("list").description("List available built-in bundle templates").option("--verbose", "show all bundle templates instead of a short preview", false).action(async (options) => {
+    await runListTemplateBundles(context, { verbose: options.verbose });
+  });
+  bundleTemplate.command("import").argument("<name>").description("Copy built-in templates into the central store").action(async (name) => {
+    await runFramedCommand(" aweskill bundle template import ", async () => runBundleAddTemplate(context, name));
+  });
+  const agent = program.command("agent").description("Manage skills used by agents");
+  agent.command("supported").description("List supported agent ids and display names").action(async () => {
+    writeSupportedAgents(context);
+  });
+  agent.command("list").description("Inspect agent skill directories and optionally normalize them").option("--global", "check global scope (default when no scope flag given)").option("--project [dir]", "check project scope; uses cwd when dir is omitted").option("--agent <agent>", 'repeat or use comma list; defaults to all; run "aweskill agent supported" to see supported ids', collectAgents).option("--update", "import missing skills into the central store and relink duplicates/new skills", false).option("--verbose", "show all skills in each category instead of a short preview", false).action(async (options) => {
+    const isProject = options.project !== void 0;
+    const scope = isProject ? "project" : "global";
+    const projectDir = isProject && typeof options.project === "string" ? options.project : void 0;
+    await runFramedCommand(
+      " aweskill agent list ",
+      async () => runCheck(context, {
+        scope,
+        agents: options.agent ?? [],
+        projectDir,
+        update: options.update,
+        verbose: options.verbose
+      })
+    );
+  });
+  agent.command("add").description("Create skill projections in agent directories").argument("<type>", "bundle or skill", getActivationType).argument("<name>", 'bundle or skill name(s), comma-separated, or "all"').option("--global", "apply to global scope (default when no scope flag given)").option("--project [dir]", "apply to project scope; uses cwd when dir is omitted").option("--agent <agent>", 'repeat or use comma list; defaults to all; run "aweskill agent supported" to see supported ids', collectAgents).action(async (type, targetName, options) => {
+    const isProject = options.project !== void 0;
+    const scope = isProject ? "project" : "global";
+    const projectDir = isProject && typeof options.project === "string" ? options.project : void 0;
+    await runFramedCommand(
+      " aweskill agent add ",
+      async () => runEnable(context, {
+        type,
+        name: targetName,
+        scope,
+        agents: options.agent ?? [],
+        projectDir
+      })
+    );
+  });
+  agent.command("remove").description("Remove skill projections in agent directories").argument("<type>", "bundle or skill", getActivationType).argument("<name>", 'bundle or skill name(s), comma-separated, or "all"').option("--global", "apply to global scope (default when no scope flag given)").option("--project [dir]", "apply to project scope; uses cwd when dir is omitted").option("--agent <agent>", 'repeat or use comma list; defaults to all; run "aweskill agent supported" to see supported ids', collectAgents).option(
+    "--force",
+    "with skill: remove projection even when this skill is in a bundle that still has other members enabled here",
+    false
+  ).action(async (type, targetName, options) => {
+    const isProject = options.project !== void 0;
+    const scope = isProject ? "project" : "global";
+    const projectDir = isProject && typeof options.project === "string" ? options.project : void 0;
+    await runFramedCommand(
+      " aweskill agent remove ",
+      async () => runDisable(context, {
+        type,
+        name: targetName,
+        scope,
+        agents: options.agent ?? [],
+        projectDir,
+        force: options.force
+      })
+    );
+  });
+  agent.command("sync").description("Remove stale managed projections whose source skill no longer exists").option("--project <dir>", "also check this project directory").action(async (options) => {
+    await runFramedCommand(" aweskill agent sync ", async () => runSync(context, { projectDir: options.project }));
+  });
+  agent.command("recover").description("Convert aweskill-managed symlink projections into full skill directories").option("--global", "recover global scope (default when no scope flag given)").option("--project [dir]", "recover project scope; uses cwd when dir is omitted").option("--agent <agent>", 'repeat or use comma list; defaults to all; run "aweskill agent supported" to see supported ids', collectAgents).action(async (options) => {
+    const isProject = options.project !== void 0;
+    const scope = isProject ? "project" : "global";
+    const projectDir = isProject && typeof options.project === "string" ? options.project : void 0;
+    await runFramedCommand(
+      " aweskill agent recover ",
+      async () => runRecover(context, {
+        scope,
+        agents: options.agent ?? [],
+        projectDir
+      })
+    );
+  });
+  const store = program.command("store").description("Manage the aweskill local store");
+  store.command("init").description("Create ~/.aweskill layout").option("--scan", "scan existing agent directories after init", false).option("--verbose", "show scanned skill details instead of per-agent totals", false).action(async (options) => {
+    await runFramedCommand(" aweskill store init ", async () => runInit(context, options));
+  });
+  store.command("backup").description("Create a timestamped archive of the central skills repository").action(async () => {
+    await runFramedCommand(" aweskill store backup ", async () => runBackup(context));
+  });
+  store.command("restore").argument("<archive>").description("Restore skills from a backup archive and auto-back up the current skills first").option("--override", "replace existing skills with the archive contents", false).action(async (archivePath, options) => {
+    await runFramedCommand(
+      " aweskill store restore ",
+      async () => runRestore(context, {
+        archivePath,
+        override: options.override
+      })
+    );
+  });
+  const doctor = program.command("doctor").description("Diagnose and repair repository issues");
+  doctor.command("dedupe").description("Find or remove duplicate central-store skills with numeric/version suffixes").option("--fix", "move duplicate skills into dup_skills (or delete them with --delete)", false).option("--delete", "when used with --fix, permanently delete duplicates instead of moving them", false).action(async (options) => {
+    await runFramedCommand(
+      " aweskill doctor dedupe ",
+      async () => runRmdup(context, {
+        remove: options.fix,
+        delete: options.delete
+      })
+    );
+  });
+  configureCommandTree(program);
+  return program;
+}
+async function main(argv = process.argv) {
+  const program = createProgram();
+  try {
+    await program.parseAsync(argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message === "(outputHelp)" || message === "outputHelp") {
+      return;
+    }
+    console.error(`Error: ${formatCliErrorMessage(message)}`);
+    process.exitCode = 1;
+  }
+}
+if (isDirectCliEntry(import.meta.url, process.argv[1])) {
+  void main();
+}
+export {
+  createProgram,
+  main
+};
+//# sourceMappingURL=index.js.map