@cmkk/agentlink 0.1.0-beta.1

package/dist/cli.js

@@ -0,0 +1,1322 @@
+// src/cli.ts
+import { cac } from "cac";
+import pc7 from "picocolors";
+
+// src/commands/clean.ts
+import pc2 from "picocolors";
+
+// src/core/linker.ts
+import { promises as fs } from "fs";
+import path from "path";
+async function applyPlans(plans, options = {}) {
+  const outcomes = [];
+  for (const plan of plans) {
+    outcomes.push(await applyOne(plan, options));
+  }
+  return outcomes;
+}
+async function applyOne(plan, options) {
+  const { dryRun = false, force = false } = options;
+  const targetDir = path.dirname(plan.target);
+  const expected = path.relative(targetDir, plan.source);
+  try {
+    const lstat = await fs.lstat(plan.target).catch(() => null);
+    if (lstat?.isSymbolicLink()) {
+      const current = await fs.readlink(plan.target);
+      if (current === expected) return { plan, status: "skipped" };
+      if (force) {
+        if (dryRun) {
+          return { plan, status: "dry-fix", message: `${current} -> ${expected}` };
+        }
+        await fs.unlink(plan.target);
+        await fs.symlink(expected, plan.target);
+        return { plan, status: "fixed", message: `${current} -> ${expected}` };
+      }
+      return {
+        plan,
+        status: "warned",
+        message: `points to ${current} (use --force to repair)`
+      };
+    }
+    if (lstat) {
+      const kind = lstat.isDirectory() ? "directory" : "file";
+      return { plan, status: "warned", message: `${kind} already exists at target` };
+    }
+    if (dryRun) {
+      return { plan, status: "dry-create" };
+    }
+    await fs.mkdir(targetDir, { recursive: true });
+    await fs.symlink(expected, plan.target);
+    return { plan, status: "created" };
+  } catch (err) {
+    return { plan, status: "errored", message: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function findStaleLinks(targetDir) {
+  const entries = await fs.readdir(targetDir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return [];
+  const stale = [];
+  for (const entry of entries) {
+    if (!entry.isSymbolicLink()) continue;
+    const full = path.join(targetDir, entry.name);
+    const exists = await fs.stat(full).catch(() => null);
+    if (!exists) stale.push(full);
+  }
+  return stale;
+}
+async function findManagedLinks(targetDir, sourceRoot, options = {}) {
+  const sourceAbs = path.resolve(sourceRoot);
+  const out = [];
+  await (async function descend(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => null);
+    if (!entries) return;
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isSymbolicLink()) {
+        const raw = await fs.readlink(full).catch(() => null);
+        if (!raw) continue;
+        const resolved = path.isAbsolute(raw) ? path.normalize(raw) : path.resolve(dir, raw);
+        if (resolved === sourceAbs || resolved.startsWith(sourceAbs + path.sep)) {
+          out.push(full);
+        }
+      } else if (options.recursive && entry.isDirectory()) {
+        await descend(full);
+      }
+    }
+  })(targetDir);
+  return out;
+}
+async function removeLinks(paths, options = {}) {
+  const { dryRun = false } = options;
+  const out = [];
+  for (const p of paths) {
+    if (dryRun) {
+      out.push({ path: p, status: "dry-remove" });
+      continue;
+    }
+    try {
+      await fs.unlink(p);
+      out.push({ path: p, status: "removed" });
+    } catch (err) {
+      out.push({
+        path: p,
+        status: "errored",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return out;
+}
+async function pruneEmptyDirs(dirs) {
+  for (const dir of dirs) {
+    await fs.rmdir(dir).catch(() => void 0);
+  }
+}
+
+// src/commands/_shared.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+import pc from "picocolors";
+
+// src/adapters/claude.ts
+var claude = {
+  name: "claude",
+  rootDir: ".claude",
+  layout: {
+    skills: { targetSubdir: "skills" },
+    rules: { targetSubdir: "rules" },
+    commands: { targetSubdir: "commands" }
+  }
+};
+
+// src/adapters/codebuddy.ts
+var codebuddy = {
+  name: "codebuddy",
+  rootDir: ".codebuddy",
+  layout: {
+    skills: { targetSubdir: "skills" },
+    rules: { targetSubdir: "rules" },
+    commands: { targetSubdir: "commands" }
+  }
+};
+
+// src/adapters/cursor.ts
+var cursor = {
+  name: "cursor",
+  rootDir: ".cursor",
+  layout: {
+    skills: { targetSubdir: "skills" },
+    rules: { targetSubdir: "rules", flatten: true, ext: ".mdc" },
+    commands: { targetSubdir: "commands", flatten: true },
+    prompts: false
+  }
+};
+
+// src/adapters/index.ts
+var adapterRegistry = {
+  cursor,
+  claude,
+  codebuddy
+};
+
+// src/core/config.ts
+import { promises as fs2 } from "fs";
+import os from "os";
+import path2 from "path";
+import stripJsonComments from "strip-json-comments";
+import { z } from "zod";
+
+// src/core/errors.ts
+var AgentlinkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var SourceNotFoundError = class extends AgentlinkError {
+  searched;
+  constructor(searched) {
+    super("no source .agents/ directory found");
+    this.searched = searched;
+  }
+};
+var InvalidPathError = class _InvalidPathError extends AgentlinkError {
+  flag;
+  path;
+  reason;
+  constructor(flag, p, reason) {
+    super(_InvalidPathError.message(flag, p, reason));
+    this.flag = flag;
+    this.path = p;
+    this.reason = reason;
+  }
+  static message(flag, p, reason) {
+    if (reason === "missing") return `${flag} does not exist: ${p}`;
+    if (reason === "not-a-directory") return `${flag} is not a directory: ${p}`;
+    return `${flag} is not a file: ${p}`;
+  }
+};
+var ConflictError = class extends AgentlinkError {
+};
+
+// src/core/types.ts
+var DEFAULT_INCLUDE = ["skills", "rules", "commands"];
+
+// src/core/config.ts
+var CONFIG_FILENAME = "agentlink.config.json";
+var ENV_CONFIG_KEY = "AGENTLINK_CONFIG";
+var ASSET_TYPE_VALUES = ["skills", "rules", "commands", "prompts", "templates", "agents"];
+var ASSET_TYPE_SET = new Set(ASSET_TYPE_VALUES);
+var assetTypeSchema = z.enum(ASSET_TYPE_VALUES);
+var targetSubdirSchema = z.string().min(1).refine((s) => !path2.isAbsolute(s), {
+  message: "targetSubdir must be relative (no leading `/` or drive letter)"
+}).refine((s) => !s.split(/[\\/]/).some((seg) => seg === ".."), {
+  message: "targetSubdir cannot traverse upward (`..` segment forbidden)"
+});
+var assetLayoutSchema = z.object({
+  targetSubdir: targetSubdirSchema.optional(),
+  flatten: z.boolean().optional(),
+  include: z.array(z.string().min(1)).optional(),
+  exclude: z.array(z.string().min(1)).optional(),
+  ext: z.string().min(1).optional()
+});
+var adapterOverrideSchema = z.union([
+  z.boolean(),
+  z.object({
+    // partialRecord: zod v4 z.record(enum,…) is exhaustive by default;
+    // partialRecord lets each key be optional, which is what users expect.
+    layout: z.partialRecord(assetTypeSchema, assetLayoutSchema).optional()
+  }).strict()
+]);
+var adapterNameSchema = z.enum(
+  Object.keys(adapterRegistry)
+);
+var configSchema = z.object({
+  include: z.array(assetTypeSchema).optional(),
+  exclude: z.array(assetTypeSchema).optional(),
+  adapters: z.partialRecord(adapterNameSchema, adapterOverrideSchema).optional()
+}).strict();
+var ConfigParseError = class extends AgentlinkError {
+  issues;
+  constructor(filePath, issues) {
+    const lines = issues.map(({ path: p, message }) => `  at ${p || "<root>"}: ${message}`);
+    super(`invalid agentlink config at ${filePath}
+${lines.join("\n")}`);
+    this.issues = issues;
+  }
+};
+async function loadConfig(opts) {
+  const location = await resolveConfigPath(opts);
+  const userConfig = location.path ? await readUserConfig(location.path) : {};
+  const adapters = mergeAdapters(userConfig.adapters);
+  const assetTypes = resolveAssetTypes(userConfig.include, userConfig.exclude);
+  return {
+    source: opts.source,
+    adapters,
+    assetTypes,
+    configPath: location.path,
+    configOrigin: location.origin
+  };
+}
+async function resolveConfigPath(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const home = opts.home ?? os.homedir();
+  const env = opts.env ?? process.env;
+  if (opts.config !== void 0 && opts.config !== "") {
+    const abs = await assertConfigFile(expandTilde(opts.config, home), "--config", cwd);
+    return { path: abs, origin: "flag" };
+  }
+  const envValue = env[ENV_CONFIG_KEY];
+  if (envValue !== void 0 && envValue !== "") {
+    const abs = await assertConfigFile(expandTilde(envValue, home), `$${ENV_CONFIG_KEY}`, cwd);
+    return { path: abs, origin: "env" };
+  }
+  const ancestor = await searchAncestors(path2.resolve(cwd), home);
+  if (ancestor) {
+    return { path: ancestor, origin: "cwd-ancestor" };
+  }
+  const homeConfig = path2.join(home, CONFIG_FILENAME);
+  if (await isFile(homeConfig)) {
+    return { path: homeConfig, origin: "home-global" };
+  }
+  return { path: null, origin: "defaults" };
+}
+async function searchAncestors(start, home) {
+  const homeAbs = path2.resolve(home);
+  let current = start;
+  while (true) {
+    if (current === homeAbs) {
+      return null;
+    }
+    const candidate = path2.join(current, CONFIG_FILENAME);
+    if (await isFile(candidate)) return candidate;
+    const parent = path2.dirname(current);
+    if (parent === current) return null;
+    if (isInside(current, homeAbs) && !isInside(parent, homeAbs) && parent !== homeAbs) {
+      return null;
+    }
+    current = parent;
+  }
+}
+async function assertConfigFile(input, flag, cwd) {
+  const abs = path2.isAbsolute(input) ? input : path2.resolve(cwd, input);
+  const stat = await fs2.stat(abs).catch(() => null);
+  if (!stat) throw new InvalidPathError(flag, abs, "missing");
+  if (!stat.isFile()) throw new InvalidPathError(flag, abs, "not-a-file");
+  return abs;
+}
+async function isFile(p) {
+  const stat = await fs2.stat(p).catch(() => null);
+  return stat?.isFile() ?? false;
+}
+function expandTilde(p, home) {
+  if (p === "~") return home;
+  if (p.startsWith("~/")) return path2.join(home, p.slice(2));
+  return p;
+}
+function isInside(child, parent) {
+  const c = path2.resolve(child);
+  const p = path2.resolve(parent);
+  if (c === p) return true;
+  const rel = path2.relative(p, c);
+  return rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
+}
+async function readExplicitAdapters(configPath) {
+  if (!configPath) return /* @__PURE__ */ new Set();
+  const raw = await fs2.readFile(configPath, "utf8").catch(() => null);
+  if (raw === null) return /* @__PURE__ */ new Set();
+  try {
+    const parsed = JSON.parse(stripJsonComments(raw, { trailingCommas: true }));
+    if (!parsed.adapters) return /* @__PURE__ */ new Set();
+    return new Set(Object.keys(parsed.adapters).filter((k) => parsed.adapters?.[k] !== false));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function readUserConfig(filePath) {
+  const raw = await fs2.readFile(filePath, "utf8").catch((err) => {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  });
+  if (raw === null) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(stripJsonComments(raw, { trailingCommas: true }));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ConfigParseError(filePath, [{ path: "", message: `not valid JSON: ${message}` }]);
+  }
+  const result = configSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => ({
+      path: issue.path.map((seg) => String(seg)).join("."),
+      message: issue.message
+    }));
+    throw new ConfigParseError(filePath, issues);
+  }
+  return result.data;
+}
+function mergeAdapters(overrides) {
+  const result = [];
+  for (const [name, preset] of Object.entries(adapterRegistry)) {
+    const override = overrides?.[name];
+    if (override === false) continue;
+    if (override === void 0 || override === true) {
+      result.push(preset);
+      continue;
+    }
+    result.push({
+      name: preset.name,
+      rootDir: preset.rootDir,
+      layout: mergeLayout(preset.layout, override.layout)
+    });
+  }
+  return result;
+}
+function mergeLayout(base, patch) {
+  if (!patch) return base;
+  const merged = { ...base };
+  for (const key of Object.keys(patch)) {
+    const value = patch[key];
+    if (value === void 0) continue;
+    const baseLayout = base[key];
+    if (baseLayout === void 0 || baseLayout === false) {
+      const targetSubdir = value.targetSubdir;
+      if (targetSubdir === void 0) {
+        throw new ConfigPatchError(
+          `adapter override for "${key}" needs a targetSubdir because the built-in adapter does not define one`
+        );
+      }
+      merged[key] = compactLayout(targetSubdir, value);
+      continue;
+    }
+    merged[key] = mergeIntoBase(baseLayout, value);
+  }
+  return merged;
+}
+function compactLayout(targetSubdir, v) {
+  const out = { targetSubdir };
+  if (v.flatten !== void 0) out.flatten = v.flatten;
+  if (v.include !== void 0) out.include = v.include;
+  if (v.exclude !== void 0) out.exclude = v.exclude;
+  if (v.ext !== void 0) out.ext = v.ext;
+  return out;
+}
+function mergeIntoBase(base, patch) {
+  const out = { ...base };
+  if (patch.targetSubdir !== void 0) out.targetSubdir = patch.targetSubdir;
+  if (patch.flatten !== void 0) out.flatten = patch.flatten;
+  if (patch.include !== void 0) out.include = patch.include;
+  if (patch.exclude !== void 0) out.exclude = patch.exclude;
+  if (patch.ext !== void 0) out.ext = patch.ext;
+  return out;
+}
+var ConfigPatchError = class extends AgentlinkError {
+};
+function resolveAssetTypes(include, exclude) {
+  const candidates = new Set(include ?? DEFAULT_INCLUDE);
+  for (const denied of exclude ?? []) {
+    candidates.delete(denied);
+  }
+  return candidates;
+}
+
+// src/core/resolve.ts
+import { promises as fs3 } from "fs";
+import os2 from "os";
+import path3 from "path";
+var ENV_SOURCE_KEY = "AGENTLINK_SOURCE";
+var AGENTS_DIRNAME = ".agents";
+async function resolvePaths(opts = {}) {
+  const [src, dst] = await Promise.all([resolveSource(opts), resolveDestRoot(opts)]);
+  if (isInside2(dst.path, src.path)) {
+    process.emitWarning(
+      `destination root "${dst.path}" lives inside source "${src.path}" \u2014 this may create self-references.`,
+      { code: "AGENTLINK_NESTED_DEST" }
+    );
+  }
+  return {
+    source: src.path,
+    sourceOrigin: src.origin,
+    destRoot: dst.path,
+    destOrigin: dst.origin
+  };
+}
+async function resolveSource(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const home = opts.home ?? os2.homedir();
+  const env = opts.env ?? process.env;
+  if (opts.source !== void 0 && opts.source !== "") {
+    const abs = await assertDir(expandTilde2(opts.source, home), "--source", cwd);
+    return { path: abs, origin: "flag" };
+  }
+  const envValue = env[ENV_SOURCE_KEY];
+  if (envValue !== void 0 && envValue !== "") {
+    const abs = await assertDir(expandTilde2(envValue, home), `$${ENV_SOURCE_KEY}`, cwd);
+    return { path: abs, origin: "env" };
+  }
+  const local = path3.join(cwd, AGENTS_DIRNAME);
+  if (await isDir(local)) {
+    return { path: local, origin: "cwd-local" };
+  }
+  const homeAgents = path3.join(home, AGENTS_DIRNAME);
+  if (await isDir(homeAgents)) {
+    return { path: homeAgents, origin: "home-global" };
+  }
+  throw new SourceNotFoundError([
+    { origin: "--source flag", status: "not provided" },
+    { origin: `$${ENV_SOURCE_KEY}`, status: "not set" },
+    { origin: local, status: "missing" },
+    { origin: homeAgents, status: "missing" }
+  ]);
+}
+async function resolveDestRoot(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const home = opts.home ?? os2.homedir();
+  if (opts.target !== void 0 && opts.target !== "" && opts.user) {
+    throw new ConflictError("--target and --user are mutually exclusive");
+  }
+  if (opts.target !== void 0 && opts.target !== "") {
+    const abs = await assertDir(expandTilde2(opts.target, home), "--target", cwd);
+    return { path: abs, origin: "flag" };
+  }
+  if (opts.user) {
+    return { path: home, origin: "user" };
+  }
+  return { path: cwd, origin: "cwd" };
+}
+function expandTilde2(p, home) {
+  if (p === "~") return home;
+  if (p.startsWith("~/")) return path3.join(home, p.slice(2));
+  return p;
+}
+async function assertDir(input, flag, cwd) {
+  const abs = path3.isAbsolute(input) ? input : path3.resolve(cwd, input);
+  const stat = await fs3.stat(abs).catch(() => null);
+  if (!stat) throw new InvalidPathError(flag, abs, "missing");
+  if (!stat.isDirectory()) throw new InvalidPathError(flag, abs, "not-a-directory");
+  return abs;
+}
+async function isDir(p) {
+  const stat = await fs3.stat(p).catch(() => null);
+  return stat?.isDirectory() ?? false;
+}
+function isInside2(child, parent) {
+  const c = path3.resolve(child);
+  const p = path3.resolve(parent);
+  if (c === p) return true;
+  const rel = path3.relative(p, c);
+  return rel !== "" && !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+
+// src/commands/_shared.ts
+async function loadContext(flags) {
+  const paths = await resolvePaths({
+    ...flags.source !== void 0 ? { source: flags.source } : {},
+    ...flags.target !== void 0 ? { target: flags.target } : {},
+    ...flags.user !== void 0 ? { user: flags.user } : {}
+  });
+  const rawConfig = await loadConfig({
+    source: paths.source,
+    ...flags.config !== void 0 ? { config: flags.config } : {}
+  });
+  const config = await gateAdapters(rawConfig, paths.destRoot);
+  return { paths, config };
+}
+async function gateAdapters(config, destRoot) {
+  const live = [];
+  for (const adapter of config.adapters) {
+    const root = path4.join(destRoot, adapter.rootDir);
+    const stat = await fs4.stat(root).catch(() => null);
+    if (stat?.isDirectory()) live.push(adapter);
+  }
+  if (live.length === config.adapters.length) return config;
+  return { ...config, adapters: live };
+}
+function printHeader(ctx, mode, flags) {
+  if (flags.quiet) return;
+  console.log("");
+  console.log(pc.bold(`[agentlink] ${mode}`));
+  console.log(`  source:   ${ctx.paths.source} ${pc.dim(`(${ctx.paths.sourceOrigin})`)}`);
+  console.log(`  target:   ${ctx.paths.destRoot} ${pc.dim(`(${ctx.paths.destOrigin})`)}`);
+  const configLine = ctx.config.configPath ? `${ctx.config.configPath} ${pc.dim(`(${ctx.config.configOrigin})`)}` : pc.dim("(defaults)");
+  console.log(`  config:   ${configLine}`);
+  console.log(`  adapters: ${ctx.config.adapters.map((a) => a.name).join(", ") || pc.dim("(none)")}`);
+  if (flags.dryRun) console.log(pc.yellow("  mode:     dry-run"));
+  console.log("");
+}
+function enumerateTargetDirs(ctx) {
+  const out = [];
+  const root = ctx.paths.destRoot;
+  for (const adapter of ctx.config.adapters) {
+    for (const assetType of ctx.config.assetTypes) {
+      const slot = adapter.layout[assetType];
+      if (slot === void 0 || slot === false) continue;
+      out.push({
+        adapter,
+        assetType,
+        targetDir: path4.join(root, adapter.rootDir, slot.targetSubdir),
+        rootDir: path4.join(root, adapter.rootDir)
+      });
+    }
+  }
+  return out;
+}
+async function enumerateAllAdapterRoots(destRoot) {
+  const out = [];
+  for (const [name, preset] of Object.entries(adapterRegistry)) {
+    const rootDir = path4.join(destRoot, preset.rootDir);
+    const stat = await fs4.stat(rootDir).catch(() => null);
+    if (stat?.isDirectory()) out.push({ name, rootDir });
+  }
+  return out;
+}
+
+// src/commands/clean.ts
+async function runClean(flags = {}) {
+  const ctx = await loadContext(flags);
+  printHeader(ctx, "clean", flags);
+  const targets = enumerateTargetDirs(ctx).map((t) => t.targetDir);
+  const stale = (await Promise.all(targets.map(findStaleLinks))).flat();
+  if (stale.length === 0) {
+    console.log(pc2.dim("  no dangling symlinks found"));
+    return;
+  }
+  const outcomes = await removeLinks(stale, flags.dryRun ? { dryRun: true } : {});
+  let cleaned = 0;
+  let dry = 0;
+  let errored = 0;
+  for (const o of outcomes) {
+    if (o.status === "removed") {
+      cleaned++;
+      if (!flags.quiet) console.log(`${pc2.yellow("[CLEAN]")} ${o.path}`);
+    } else if (o.status === "dry-remove") {
+      dry++;
+      if (!flags.quiet) console.log(`${pc2.dim("[DRY]")}   would clean ${o.path}`);
+    } else if (o.status === "errored") {
+      errored++;
+      console.error(`${pc2.red("[ERR]")}   ${o.path} ${pc2.dim(`(${o.message ?? ""})`)}`);
+    }
+  }
+  console.log("");
+  const parts = [];
+  if (cleaned) parts.push(pc2.yellow(`${cleaned} cleaned`));
+  if (dry) parts.push(pc2.dim(`${dry} dry-run`));
+  if (errored) parts.push(pc2.red(`${errored} errored`));
+  console.log(parts.length === 0 ? pc2.dim("  no changes") : `  ${parts.join(", ")}`);
+  if (errored > 0) process.exitCode = 1;
+}
+
+// src/commands/doctor.ts
+import { promises as fs6 } from "fs";
+import path6 from "path";
+import pc3 from "picocolors";
+
+// src/core/layout.ts
+import { promises as fs5 } from "fs";
+import path5 from "path";
+import picomatch from "picomatch";
+async function buildLinkPlans(opts) {
+  const { source, destRoot, config } = opts;
+  const draft = [];
+  for (const adapter of config.adapters) {
+    for (const assetType of config.assetTypes) {
+      const slot = adapter.layout[assetType];
+      if (slot === void 0 || slot === false) continue;
+      const sourceAssetDir = path5.join(source, assetType);
+      if (!await isDir2(sourceAssetDir)) continue;
+      const targetAssetDir = path5.join(destRoot, adapter.rootDir, slot.targetSubdir);
+      const planned = slot.flatten ? await planFlattened(sourceAssetDir, targetAssetDir, slot, adapter, assetType) : await planShallow(sourceAssetDir, targetAssetDir, slot, adapter, assetType);
+      draft.push(...planned);
+    }
+  }
+  return splitByCollision(draft);
+}
+async function planFlattened(sourceAssetDir, targetAssetDir, layout, adapter, assetType) {
+  const files = await walkFiles(sourceAssetDir);
+  const includeMatch = makeIncludeMatcher(layout.include);
+  const excludeMatch = makeExcludeMatcher(layout.exclude);
+  const out = [];
+  for (const abs of files) {
+    const rel = path5.relative(sourceAssetDir, abs);
+    if (!includeMatch(rel)) continue;
+    if (excludeMatch(rel)) continue;
+    const targetName = applyRename(
+      rel,
+      layout,
+      /* flatten */
+      true
+    );
+    out.push({
+      source: abs,
+      target: path5.join(targetAssetDir, targetName),
+      adapterName: adapter.name,
+      assetType,
+      flattened: true
+    });
+  }
+  return out;
+}
+async function planShallow(sourceAssetDir, targetAssetDir, layout, adapter, assetType) {
+  const items = await listFirstLevel(sourceAssetDir);
+  const includeMatch = makeIncludeMatcher(layout.include);
+  const excludeMatch = makeExcludeMatcher(layout.exclude);
+  const out = [];
+  for (const entry of items) {
+    if (!includeMatch(entry.name)) continue;
+    if (excludeMatch(entry.name)) continue;
+    const targetName = applyRename(
+      entry.name,
+      layout,
+      /* flatten */
+      false
+    );
+    out.push({
+      source: path5.join(sourceAssetDir, entry.name),
+      target: path5.join(targetAssetDir, targetName),
+      adapterName: adapter.name,
+      assetType,
+      flattened: false
+    });
+  }
+  return out;
+}
+var PATH_SEPARATOR_RE = /[\\/]/g;
+function applyRename(relPath, layout, flatten) {
+  if (layout.rename) return layout.rename(relPath);
+  let name = flatten ? relPath.replace(PATH_SEPARATOR_RE, "__") : relPath;
+  if (layout.ext) {
+    const ext = path5.extname(name);
+    name = ext ? name.slice(0, -ext.length) + layout.ext : name + layout.ext;
+  }
+  return name;
+}
+async function walkFiles(root) {
+  const out = [];
+  await (async function descend(dir) {
+    const entries = await fs5.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const full = path5.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await descend(full);
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        out.push(full);
+      }
+    }
+  })(root);
+  return out;
+}
+async function listFirstLevel(root) {
+  const entries = await fs5.readdir(root, { withFileTypes: true });
+  return entries.filter((e) => !e.name.startsWith(".")).map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+}
+async function isDir2(p) {
+  const stat = await fs5.stat(p).catch(() => null);
+  return stat?.isDirectory() ?? false;
+}
+function makeIncludeMatcher(patterns) {
+  if (!patterns || patterns.length === 0) return () => true;
+  const fns = patterns.map((p) => picomatch(p, { dot: true }));
+  return (rel) => fns.some((fn) => fn(rel));
+}
+function makeExcludeMatcher(patterns) {
+  if (!patterns || patterns.length === 0) return () => false;
+  const fns = patterns.map((p) => picomatch(p, { dot: true }));
+  return (rel) => fns.some((fn) => fn(rel));
+}
+function splitByCollision(plans) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const plan of plans) {
+    const bucket = byTarget.get(plan.target);
+    if (bucket) bucket.push(plan);
+    else byTarget.set(plan.target, [plan]);
+  }
+  const accepted = [];
+  const collisions = [];
+  for (const [target, bucket] of byTarget) {
+    if (bucket.length === 1) {
+      accepted.push(bucket[0]);
+      continue;
+    }
+    const head = bucket[0];
+    collisions.push({
+      target,
+      sources: bucket.map((p) => p.source),
+      adapterName: head.adapterName,
+      assetType: head.assetType
+    });
+  }
+  return { plans: accepted, collisions };
+}
+
+// src/commands/doctor.ts
+async function runDoctor(flags = {}) {
+  const ctx = await loadContext(flags);
+  printHeader(ctx, "doctor", flags);
+  let warnings = 0;
+  let errors = 0;
+  const explicitlyEnabled = await readExplicitAdapters(ctx.config.configPath);
+  console.log(pc3.bold("Adapters"));
+  for (const [name, preset] of Object.entries(adapterRegistry)) {
+    const root = path6.join(ctx.paths.destRoot, preset.rootDir);
+    const stat = await fs6.stat(root).catch(() => null);
+    if (stat?.isDirectory()) {
+      console.log(
+        `  ${pc3.green("\u2713")} ${name.padEnd(11)} ${pc3.dim(preset.rootDir + "/")} ${pc3.dim("(active)")}`
+      );
+    } else if (explicitlyEnabled.has(name)) {
+      warnings++;
+      console.log(
+        `  ${pc3.yellow("\u26A0")} ${name.padEnd(11)} ${pc3.dim(preset.rootDir + "/")} ${pc3.yellow("rootDir not found \u2014 sync will skip")}`
+      );
+    } else {
+      console.log(
+        `  ${pc3.dim("\u2014")} ${name.padEnd(11)} ${pc3.dim(preset.rootDir + "/")} ${pc3.dim("not in use on this machine")}`
+      );
+    }
+  }
+  console.log("");
+  const { plans, collisions } = await buildLinkPlans({
+    source: ctx.paths.source,
+    destRoot: ctx.paths.destRoot,
+    config: ctx.config
+  });
+  console.log(pc3.bold("Link plan"));
+  console.log(`  ${plans.length} plan${plans.length === 1 ? "" : "s"}`);
+  if (collisions.length === 0) {
+    console.log(`  ${pc3.green("\u2713")} no collisions`);
+  } else {
+    warnings += collisions.length;
+    console.log(`  ${pc3.yellow("\u26A0")} ${collisions.length} collision(s):`);
+    for (const c of collisions) {
+      console.log(`     ${pc3.dim(c.adapterName + "/" + c.assetType)}  ${c.target}`);
+      for (const s of c.sources) console.log(`       ${pc3.dim("\u2190")} ${s}`);
+    }
+  }
+  console.log("");
+  const targetDirs = enumerateTargetDirs(ctx).map((t) => t.targetDir);
+  const stale = (await Promise.all(targetDirs.map(findStaleLinks))).flat();
+  const allRoots = await enumerateAllAdapterRoots(ctx.paths.destRoot);
+  const managed = (await Promise.all(
+    allRoots.map((r) => findManagedLinks(r.rootDir, ctx.paths.source, { recursive: true }))
+  )).flat();
+  const staleSet = new Set(stale);
+  const planTargets = new Set(plans.map((p) => p.target));
+  const orphans = managed.filter((p) => !planTargets.has(p) && !staleSet.has(p));
+  console.log(pc3.bold("Existing links"));
+  if (stale.length === 0 && orphans.length === 0) {
+    console.log(`  ${pc3.green("\u2713")} all clear`);
+  } else {
+    if (stale.length > 0) {
+      warnings += stale.length;
+      console.log(
+        `  ${pc3.yellow("\u26A0")} ${stale.length} dangling ${pc3.dim("(run `agentlink clean` to drop):")}`
+      );
+      for (const p of stale) console.log(`     ${p}`);
+    }
+    if (orphans.length > 0) {
+      warnings += orphans.length;
+      console.log(
+        `  ${pc3.yellow("\u26A0")} ${orphans.length} orphan ${pc3.dim("(linked into source but not in current plan; `unlink` then `sync` will rebuild):")}`
+      );
+      for (const p of orphans) console.log(`     ${p}`);
+    }
+  }
+  console.log("");
+  if (warnings + errors === 0) {
+    console.log(pc3.green("Healthy"));
+    return;
+  }
+  const parts = [];
+  if (warnings > 0) parts.push(pc3.yellow(`${warnings} warning${warnings === 1 ? "" : "s"}`));
+  if (errors > 0) parts.push(pc3.red(`${errors} error${errors === 1 ? "" : "s"}`));
+  console.log(`Issues: ${parts.join(", ")}`);
+  if (errors > 0) process.exitCode = 1;
+}
+
+// src/commands/init.ts
+import { promises as fs7 } from "fs";
+import os3 from "os";
+import path8 from "path";
+import { fileURLToPath } from "url";
+import pc5 from "picocolors";
+import prompts from "prompts";
+
+// src/commands/sync.ts
+import path7 from "path";
+import pc4 from "picocolors";
+var StrictModeViolation = class extends AgentlinkError {
+  constructor(conflicts) {
+    super(`${conflicts.length} link target collision(s) under --strict`);
+    this.conflicts = conflicts;
+  }
+  conflicts;
+};
+async function runSync(flags = {}) {
+  const ctx = await loadContext(flags);
+  printHeader(ctx, "sync", flags);
+  const { plans, collisions } = await buildLinkPlans({
+    source: ctx.paths.source,
+    destRoot: ctx.paths.destRoot,
+    config: ctx.config
+  });
+  if (collisions.length > 0) {
+    reportCollisions(collisions, flags.quiet ?? false);
+    if (flags.strict) {
+      throw new StrictModeViolation(collisions);
+    }
+  }
+  const outcomes = await applyPlans(plans, {
+    ...flags.dryRun !== void 0 ? { dryRun: flags.dryRun } : {},
+    ...flags.force !== void 0 ? { force: flags.force } : {}
+  });
+  const targetDirs = enumerateTargetDirs(ctx).map((t) => t.targetDir);
+  const stale = (await Promise.all(targetDirs.map(findStaleLinks))).flat();
+  const removed = await removeLinks(stale, flags.dryRun ? { dryRun: true } : {});
+  reportOutcomes(outcomes, ctx.paths.destRoot, flags.quiet ?? false);
+  reportRemovals(removed, flags.quiet ?? false);
+  printSummary(outcomes, removed, collisions);
+  const errored = outcomes.filter((o) => o.status === "errored").length + removed.filter((r) => r.status === "errored").length;
+  if (errored > 0) process.exitCode = 1;
+}
+function reportCollisions(collisions, quiet) {
+  if (quiet) return;
+  for (const c of collisions) {
+    console.warn(
+      pc4.yellow(`[WARN] target collision under ${c.adapterName}/${c.assetType}: ${c.target}`)
+    );
+    for (const s of c.sources) console.warn(pc4.dim(`        source: ${s}`));
+  }
+}
+function reportOutcomes(outcomes, destRoot, quiet) {
+  for (const o of outcomes) {
+    const display = path7.relative(destRoot, o.plan.target);
+    switch (o.status) {
+      case "created":
+        if (!quiet) console.log(`${pc4.green("[OK]")}    ${display}`);
+        break;
+      case "fixed":
+        console.log(`${pc4.green("[FIX]")}   ${display} ${pc4.dim(`(${o.message})`)}`);
+        break;
+      case "skipped":
+        if (!quiet) console.log(`${pc4.cyan("[SKIP]")}  ${display}`);
+        break;
+      case "warned":
+        console.warn(`${pc4.yellow("[WARN]")}  ${display} ${pc4.dim(`(${o.message ?? ""})`)}`);
+        break;
+      case "errored":
+        console.error(`${pc4.red("[ERR]")}   ${display} ${pc4.dim(`(${o.message ?? ""})`)}`);
+        break;
+      case "dry-create":
+        if (!quiet) console.log(`${pc4.dim("[DRY]")}   ${display}`);
+        break;
+      case "dry-fix":
+        console.log(`${pc4.dim("[DRY]")}   ${display} ${pc4.dim(`(would fix: ${o.message})`)}`);
+        break;
+    }
+  }
+}
+function reportRemovals(removals, quiet) {
+  for (const r of removals) {
+    if (r.status === "removed" && !quiet) {
+      console.log(`${pc4.yellow("[CLEAN]")} ${r.path}`);
+    } else if (r.status === "dry-remove" && !quiet) {
+      console.log(`${pc4.dim("[DRY]")}   would clean ${r.path}`);
+    } else if (r.status === "errored") {
+      console.error(`${pc4.red("[ERR]")}   ${r.path} ${pc4.dim(`(${r.message ?? ""})`)}`);
+    }
+  }
+}
+function printSummary(outcomes, removals, collisions) {
+  const counts = {};
+  for (const o of outcomes) counts[o.status] = (counts[o.status] ?? 0) + 1;
+  const cleaned = removals.filter((r) => r.status === "removed" || r.status === "dry-remove").length;
+  const parts = [];
+  if (counts["created"]) parts.push(pc4.green(`${counts["created"]} created`));
+  if (counts["fixed"]) parts.push(pc4.green(`${counts["fixed"]} fixed`));
+  if (counts["skipped"]) parts.push(pc4.cyan(`${counts["skipped"]} skipped`));
+  if (counts["warned"]) parts.push(pc4.yellow(`${counts["warned"]} warned`));
+  if (counts["errored"]) parts.push(pc4.red(`${counts["errored"]} errored`));
+  if (counts["dry-create"] || counts["dry-fix"]) {
+    parts.push(pc4.dim(`${(counts["dry-create"] ?? 0) + (counts["dry-fix"] ?? 0)} dry-run`));
+  }
+  if (cleaned) parts.push(pc4.yellow(`${cleaned} cleaned`));
+  if (collisions.length) parts.push(pc4.yellow(`${collisions.length} collision(s)`));
+  console.log("");
+  console.log(parts.length === 0 ? pc4.dim("  no changes") : `  ${parts.join(", ")}`);
+}
+
+// src/commands/init.ts
+var InitTargetExistsError = class extends AgentlinkError {
+  constructor(targetPath) {
+    super(`refusing to scaffold into a non-empty directory: ${targetPath}
+  use --force to merge into the existing files`);
+  }
+};
+var ALL_ASSET_TYPES = ["skills", "rules", "commands", "prompts", "templates", "agents"];
+var DEFAULT_ASSET_TYPES = ["skills", "rules", "commands"];
+var ALL_ADAPTER_NAMES = Object.keys(adapterRegistry);
+var HERE = path8.dirname(fileURLToPath(import.meta.url));
+var TEMPLATE_CANDIDATES = [
+  path8.resolve(HERE, "..", "templates", "v1"),
+  path8.resolve(HERE, "..", "..", "templates", "v1")
+];
+async function findTemplatesDir() {
+  for (const candidate of TEMPLATE_CANDIDATES) {
+    const stat = await fs7.stat(candidate).catch(() => null);
+    if (stat?.isDirectory()) return candidate;
+  }
+  throw new AgentlinkError(
+    `agentlink templates dir not found; searched:
+  ${TEMPLATE_CANDIDATES.join("\n  ")}`
+  );
+}
+async function runInit(flags = {}) {
+  const answers = await collectAnswers(flags);
+  if (!flags.quiet) {
+    console.log("");
+    console.log(pc5.bold("[agentlink] init"));
+    console.log(`  target:   ${answers.target}`);
+    console.log("");
+  }
+  const created = await scaffoldInto(answers, {
+    force: flags.force ?? false,
+    quiet: flags.quiet ?? false,
+    dryRun: flags.dryRun ?? false
+  });
+  if (!created.touched && !flags.quiet) {
+    console.log(pc5.dim("  no files written; .agents/ already populated"));
+  }
+  if (answers.targetCategory === "custom" && !flags.quiet) {
+    printNonDefaultLocationHint(answers.target);
+  }
+  if (!flags.quiet) console.log("");
+  if (flags.dryRun) {
+    if (!flags.quiet) {
+      console.log(
+        pc5.dim(
+          `  (dry-run) would run \`agentlink sync\` against ${answers.target} after scaffolding`
+        )
+      );
+    }
+    return;
+  }
+  await runSync({
+    source: answers.target,
+    ...flags.target !== void 0 ? { target: flags.target } : {},
+    ...flags.user !== void 0 ? { user: flags.user } : {},
+    ...flags.quiet !== void 0 ? { quiet: flags.quiet } : {}
+  });
+}
+async function collectAnswers(flags) {
+  const skipPrompts = flags.yes || !process.stdin.isTTY;
+  let target;
+  let targetCategory;
+  if (flags.source !== void 0 && flags.source !== "") {
+    target = path8.resolve(expandTilde3(flags.source));
+    targetCategory = categorizeTarget(target);
+  } else if (flags.local) {
+    target = path8.resolve(process.cwd(), ".agents");
+    targetCategory = "cwd";
+  } else if (skipPrompts) {
+    target = path8.resolve(os3.homedir(), ".agents");
+    targetCategory = "home";
+  } else {
+    const choice = await ask({
+      type: "select",
+      name: "kind",
+      message: "Where should agentlink put your .agents/ directory?",
+      choices: [
+        {
+          title: "Personal global (~/.agents)",
+          description: "Recommended \u2014 share assets across every project",
+          value: "home"
+        },
+        {
+          title: "Repo-local (./.agents)",
+          description: "Ship a curated .agents/ inside this repository",
+          value: "cwd"
+        }
+      ],
+      initial: 0
+    });
+    target = choice.kind === "home" ? path8.resolve(os3.homedir(), ".agents") : path8.resolve(process.cwd(), ".agents");
+    targetCategory = choice.kind;
+  }
+  let include;
+  if (skipPrompts) {
+    include = DEFAULT_ASSET_TYPES;
+  } else {
+    const { values } = await ask({
+      type: "multiselect",
+      name: "values",
+      message: "Which asset types do you want to manage?",
+      hint: "space to toggle, enter to confirm",
+      choices: ALL_ASSET_TYPES.map((name) => ({
+        title: name,
+        value: name,
+        selected: DEFAULT_ASSET_TYPES.includes(name)
+      })),
+      min: 1,
+      instructions: false
+    });
+    include = values;
+  }
+  let adapters;
+  if (skipPrompts) {
+    adapters = ALL_ADAPTER_NAMES;
+  } else {
+    const { values } = await ask({
+      type: "multiselect",
+      name: "values",
+      message: "Which AI agents do you want to target?",
+      hint: "space to toggle, enter to confirm",
+      choices: ALL_ADAPTER_NAMES.map((name) => ({
+        title: name,
+        value: name,
+        selected: true
+      })),
+      min: 1,
+      instructions: false
+    });
+    adapters = values;
+  }
+  const configCategory = targetCategory === "cwd" ? "cwd" : "home";
+  const configPath = configCategory === "home" ? path8.resolve(os3.homedir(), "agentlink.config.json") : path8.resolve(process.cwd(), "agentlink.config.json");
+  return { target, targetCategory, configPath, configCategory, include, adapters };
+}
+async function ask(question) {
+  let cancelled = false;
+  const answer = await prompts(question, {
+    onCancel: () => {
+      cancelled = true;
+      return false;
+    }
+  });
+  if (cancelled) throw new AgentlinkError("init cancelled");
+  return answer;
+}
+function categorizeTarget(target) {
+  const home = path8.resolve(os3.homedir(), ".agents");
+  const cwd = path8.resolve(process.cwd(), ".agents");
+  if (target === home) return "home";
+  if (target === cwd) return "cwd";
+  return "custom";
+}
+function expandTilde3(p) {
+  if (p === "~") return os3.homedir();
+  if (p.startsWith("~/")) return path8.join(os3.homedir(), p.slice(2));
+  return p;
+}
+async function scaffoldInto(answers, options) {
+  const { force, quiet, dryRun } = options;
+  const target = answers.target;
+  const stat = await fs7.stat(target).catch(() => null);
+  if (stat && !stat.isDirectory()) {
+    throw new AgentlinkError(`init target exists but is not a directory: ${target}`);
+  }
+  if (stat && !force) {
+    const entries = await fs7.readdir(target);
+    if (entries.length > 0) throw new InitTargetExistsError(target);
+  }
+  if (!dryRun) {
+    await fs7.mkdir(target, { recursive: true });
+  } else if (!stat && !quiet) {
+    console.log(`${pc5.dim("[DRY]")}   would create ${target}/`);
+  }
+  const templatesDir = await findTemplatesDir();
+  let written = 0;
+  written += await copyStaticAssets(templatesDir, target, answers.include, quiet, dryRun);
+  written += await writeConfigFile(answers, quiet, dryRun);
+  return { touched: written > 0 };
+}
+async function copyStaticAssets(templatesDir, target, include, quiet, dryRun) {
+  let written = 0;
+  const readmeSrc = path8.join(templatesDir, "README.md");
+  const readmeDest = path8.join(target, "README.md");
+  if (await fs7.stat(readmeSrc).catch(() => null) && !await fs7.stat(readmeDest).catch(() => null)) {
+    if (dryRun) {
+      if (!quiet) console.log(`${pc5.dim("[DRY]")}   would create ${readmeDest}`);
+    } else {
+      await fs7.copyFile(readmeSrc, readmeDest);
+      if (!quiet) console.log(`${pc5.green("[NEW]")}   ${readmeDest}`);
+    }
+    written++;
+  }
+  for (const assetType of include) {
+    const dir = path8.join(target, assetType);
+    const keep = path8.join(dir, ".gitkeep");
+    const keepExists = await fs7.stat(keep).catch(() => null);
+    if (keepExists) continue;
+    if (dryRun) {
+      if (!quiet) console.log(`${pc5.dim("[DRY]")}   would create ${keep}`);
+    } else {
+      await fs7.mkdir(dir, { recursive: true });
+      await fs7.writeFile(keep, "");
+      if (!quiet) console.log(`${pc5.green("[NEW]")}   ${keep}`);
+    }
+    written++;
+  }
+  return written;
+}
+async function writeConfigFile(answers, quiet, dryRun) {
+  const configPath = answers.configPath;
+  if (await fs7.stat(configPath).catch(() => null)) {
+    if (!quiet) console.log(`${pc5.cyan("[SKIP]")}  ${configPath} (already exists)`);
+    return 0;
+  }
+  if (dryRun) {
+    if (!quiet) console.log(`${pc5.dim("[DRY]")}   would create ${configPath}`);
+    return 1;
+  }
+  await fs7.mkdir(path8.dirname(configPath), { recursive: true });
+  await fs7.writeFile(configPath, renderConfig(answers), "utf8");
+  if (!quiet) console.log(`${pc5.green("[NEW]")}   ${configPath}`);
+  return 1;
+}
+function renderConfig(answers) {
+  const includeJson = JSON.stringify(answers.include);
+  const adapterLines = ALL_ADAPTER_NAMES.map((name) => {
+    const value = answers.adapters.includes(name) ? "true" : "false";
+    return `    "${name}": ${value}`;
+  }).join(",\n");
+  return `{
+  // Asset type allowlist. Default: ["skills", "rules", "commands"].
+  // Add "prompts", "templates" or "agents" here to opt them in.
+  "include": ${includeJson},
+
+  // Asset type denylist (always wins over \`include\`).
+  "exclude": [],
+
+  // Per-adapter overrides. Each value can be:
+  //   - true                       : enable with built-in defaults
+  //   - false                      : disable even if its rootDir exists
+  //   - { "layout": { \u2026 } }        : enable + override specific asset layouts
+  //
+  // Example: keep cursor commands nested instead of flattened
+  //   "cursor": { "layout": { "commands": { "flatten": false } } }
+  "adapters": {
+${adapterLines}
+  }
+}
+`;
+}
+function printNonDefaultLocationHint(target) {
+  console.log("");
+  console.log(pc5.bold("Tip \u2014 your source is at a non-default location:"));
+  console.log(`  ${target}`);
+  console.log("");
+  console.log("Future invocations of `agentlink sync` need to know about it. Either:");
+  console.log(`  - pass ${pc5.cyan(`--source ${target}`)} each time, or`);
+  console.log(`  - export ${pc5.cyan(`AGENTLINK_SOURCE=${target}`)} in your shell rc, or`);
+  console.log(`  - symlink it: ${pc5.cyan(`ln -s ${target} ~/.agents`)}`);
+}
+
+// src/commands/unlink.ts
+import pc6 from "picocolors";
+async function runUnlink(flags = {}) {
+  const ctx = await loadContext(flags);
+  printHeader(ctx, "unlink", flags);
+  const roots = await enumerateAllAdapterRoots(ctx.paths.destRoot);
+  const sourceRoot = ctx.paths.source;
+  const owned = (await Promise.all(
+    roots.map(({ rootDir }) => findManagedLinks(rootDir, sourceRoot, { recursive: true }))
+  )).flat();
+  if (owned.length === 0) {
+    console.log(pc6.dim("  no agentlink-managed links found"));
+    return;
+  }
+  const outcomes = await removeLinks(owned, flags.dryRun ? { dryRun: true } : {});
+  let removed = 0;
+  let dry = 0;
+  let errored = 0;
+  for (const o of outcomes) {
+    if (o.status === "removed") {
+      removed++;
+      if (!flags.quiet) console.log(`${pc6.yellow("[UNLINK]")} ${o.path}`);
+    } else if (o.status === "dry-remove") {
+      dry++;
+      if (!flags.quiet) console.log(`${pc6.dim("[DRY]")}    would remove ${o.path}`);
+    } else if (o.status === "errored") {
+      errored++;
+      console.error(`${pc6.red("[ERR]")}    ${o.path} ${pc6.dim(`(${o.message ?? ""})`)}`);
+    }
+  }
+  if (!flags.dryRun) {
+    await pruneEmptyDirs(roots.map((r) => r.rootDir));
+  }
+  console.log("");
+  const parts = [];
+  if (removed) parts.push(pc6.yellow(`${removed} removed`));
+  if (dry) parts.push(pc6.dim(`${dry} dry-run`));
+  if (errored) parts.push(pc6.red(`${errored} errored`));
+  console.log(parts.length === 0 ? pc6.dim("  no changes") : `  ${parts.join(", ")}`);
+  if (errored > 0) process.exitCode = 1;
+}
+
+// src/cli.ts
+var PKG_NAME = "@cmkk/agentlink";
+var PKG_VERSION = "0.1.0";
+function applyGlobalOptions(cli) {
+  cli.option("--source <path>", "Override the source .agents/ location").option("-t, --target <dir>", "Run against a specific destination root").option("-u, --user", "Link into $HOME (user-level install target)").option("--config <path>", "Load a specific agentlink.config.json").option("-n, --dry-run", "Preview changes without touching the filesystem").option("-f, --force", "Replace symlinks that point somewhere unexpected").option("-q, --quiet", "Only print changes and errors").option("-v, --verbose", "Print debug-level output").option("--strict", "Treat collisions as errors instead of warnings");
+}
+async function main() {
+  const cli = cac("agentlink");
+  cli.command("init", "Create an empty .agents/ scaffold and run sync once").option("--local", "Scaffold into ./.agents instead of ~/.agents").option("-y, --yes", "Skip interactive prompts and use defaults (CI-friendly)").action((flags) => runInit(flags));
+  cli.command("sync", "Refresh all symlinks (default command)").action((flags) => runSync(flags));
+  cli.command("clean", "Remove dangling agentlink-managed symlinks").action((flags) => runClean(flags));
+  cli.command("unlink", "Remove every symlink agentlink ever created").action((flags) => runUnlink(flags));
+  cli.command("doctor", "Diagnose configuration, adapters, and link health").action((flags) => runDoctor(flags));
+  cli.command("", "Default command (alias for `sync`)").action((flags) => runSync(flags));
+  applyGlobalOptions(cli);
+  cli.help();
+  cli.version(PKG_VERSION);
+  try {
+    cli.parse(process.argv, { run: false });
+    await cli.runMatchedCommand();
+  } catch (err) {
+    renderError(err);
+    process.exit(1);
+  }
+}
+function renderError(err) {
+  if (err instanceof SourceNotFoundError) {
+    console.error(pc7.red(`[${PKG_NAME}] no source .agents/ directory found.
+`));
+    console.error("Searched:");
+    for (const { origin, status } of err.searched) {
+      console.error(`  ${origin.padEnd(40)} ${pc7.dim(status)}`);
+    }
+    console.error("");
+    console.error("Hints:");
+    console.error("  - run `agentlink init` to scaffold ~/.agents/");
+    console.error("  - run `agentlink init --local` to scaffold ./.agents/");
+    console.error("  - or pass `--source <path>` explicitly");
+    return;
+  }
+  if (err instanceof StrictModeViolation) {
+    console.error(pc7.red(`[${PKG_NAME}] aborted: ${err.message}`));
+    console.error(pc7.dim("  rerun without --strict to accept the warnings, or fix the source."));
+    return;
+  }
+  if (err instanceof ConfigParseError) {
+    console.error(pc7.red(`[${PKG_NAME}] ${err.message}`));
+    return;
+  }
+  if (err instanceof InvalidPathError || err instanceof ConflictError) {
+    console.error(pc7.red(`[${PKG_NAME}] ${err.message}`));
+    return;
+  }
+  if (err instanceof AgentlinkError) {
+    console.error(pc7.red(`[${PKG_NAME}] ${err.message}`));
+    return;
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(pc7.red(`[${PKG_NAME}] ${msg}`));
+  if (process.env["AGENTLINK_DEBUG"]) {
+    console.error(err);
+  }
+}
+await main();
+//# sourceMappingURL=cli.js.map