@ccpluginizer/ccpluginizer 0.2.0

package/dist/index.js

@@ -0,0 +1,1925 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../../node_modules/.bun/@crustjs+core@0.0.16+7524df1edfed9f02/node_modules/@crustjs/core/dist/shared/chunk-vt64gs69.js
+import { parseArgs as U } from "util";
+function q(B) {
+  let J = {}, G = {};
+  if (!B)
+    return { options: J, aliasToName: G };
+  let z = new Map;
+  for (let j of Object.keys(B))
+    z.set(j, j);
+  for (let [j, H] of Object.entries(B)) {
+    if (j.startsWith("no-")) {
+      let L = j.slice(3);
+      throw new W("DEFINITION", `Flag "--${j}" must not use "no-" prefix; define "${L}" and negate with "--no-${L}"`);
+    }
+    let K = H.type === "boolean" ? "boolean" : "string", Q = { type: K };
+    if (H.multiple)
+      Q.multiple = true;
+    if (H.short) {
+      if (H.short.startsWith("no-"))
+        throw new W("DEFINITION", `Short alias "-${H.short}" on "--${j}" must not use "no-" prefix (reserved for negation)`);
+      let L = z.get(H.short);
+      if (L)
+        throw new W("DEFINITION", `Alias collision: "-${H.short}" is used by both "--${L}" and "--${j}"`);
+      z.set(H.short, j), G[H.short] = j, Q.short = H.short;
+    }
+    if (H.aliases)
+      for (let L of H.aliases) {
+        if (L.startsWith("no-"))
+          throw new W("DEFINITION", `Alias "--${L}" on "--${j}" must not use "no-" prefix (reserved for negation)`);
+        let X = z.get(L);
+        if (X)
+          throw new W("DEFINITION", `Alias collision: "${L.length === 1 ? "-" : "--"}${L}" is used by both "--${X}" and "--${j}"`);
+        z.set(L, j), G[L] = j;
+        let $ = { type: K };
+        if (H.multiple)
+          $.multiple = true;
+        J[L] = $;
+      }
+    J[j] = Q;
+  }
+  return { options: J, aliasToName: G };
+}
+function _(B, J, G) {
+  if (J === "number") {
+    let z = Number(B);
+    if (Number.isNaN(z))
+      throw new W("PARSE", `Expected number for ${G}, got "${B}"`);
+    return z;
+  }
+  if (J === "boolean")
+    return B === "true" || B === "1";
+  return B;
+}
+function I(B, J, G) {
+  let z = `--${B}`;
+  if (J.multiple && Array.isArray(G))
+    return J.type === "boolean" ? G.filter((j) => typeof j === "boolean") : G.map((j) => _(j, J.type, z));
+  if (J.type === "boolean") {
+    if (typeof G === "boolean")
+      return G;
+    throw new W("PARSE", `Expected boolean value for flag "${z}", got ${typeof G}`);
+  }
+  if (typeof G === "string")
+    return _(G, J.type, z);
+  if (G === true)
+    return J.default ?? undefined;
+  return G;
+}
+function M(B, J, G) {
+  let z = {};
+  for (let j in B) {
+    let H = J[j] ?? j;
+    if (!(H in G))
+      continue;
+    let K = B[j], Q = z[H];
+    if (Q !== undefined && Array.isArray(Q) && Array.isArray(K))
+      Q.push(...K);
+    else
+      z[H] = K;
+  }
+  return z;
+}
+function h(B, J, G) {
+  if (!B)
+    return {};
+  let z = M(J, G, B), j = {};
+  for (let [H, K] of Object.entries(B)) {
+    let Q = z[H];
+    if (Q !== undefined) {
+      j[H] = I(H, K, Q);
+      continue;
+    }
+    j[H] = K.default ?? undefined;
+  }
+  return j;
+}
+function O(B, J) {
+  if (!B)
+    return;
+  for (let [G, z] of Object.entries(B))
+    if (z.required === true && z.default === undefined) {
+      if (J[G] === undefined)
+        throw new W("VALIDATION", `Missing required flag "--${G}"`);
+    }
+}
+function P(B, J) {
+  if (!B)
+    return {};
+  let G = {}, z = 0;
+  for (let j of B) {
+    let { name: H } = j;
+    if (j.variadic) {
+      let K = J.slice(z);
+      G[H] = j.type === "string" ? K : K.map((Q) => _(Q, j.type, `<${H}>`)), z = J.length;
+    } else if (z < J.length)
+      G[H] = _(J[z], j.type, `<${H}>`), z++;
+    else
+      G[H] = j.default ?? undefined;
+  }
+  return G;
+}
+function S(B, J, G) {
+  if (!J)
+    return;
+  for (let z of B) {
+    if (z === "--")
+      return;
+    if (!z.startsWith("--no-"))
+      continue;
+    let j = z.indexOf("="), H = j === -1 ? z.slice(5) : z.slice(5, j);
+    if (!H)
+      continue;
+    let K = G[H];
+    if (!K)
+      continue;
+    if (K === H)
+      continue;
+    if (J[K]?.type !== "boolean")
+      continue;
+    throw new W("PARSE", `Cannot negate alias "--no-${H}"; use "--no-${K}" instead`);
+  }
+}
+function b(B, J) {
+  let { args: G, effectiveFlags: z } = B, { options: j, aliasToName: H } = q(z);
+  S(J, z, H);
+  let K;
+  try {
+    K = U({ args: J, options: j, strict: true, allowPositionals: true, allowNegative: true, tokens: true });
+  } catch (Y) {
+    if (Y instanceof Error) {
+      let Z = Y.message.match(/Unknown option '(.+?)'/);
+      if (Z)
+        throw new W("PARSE", `Unknown flag "${Z[1]}"`).withCause(Y);
+    }
+    throw new W("PARSE", "Failed to parse command arguments").withCause(Y);
+  }
+  let Q = [], L = [];
+  if (K.tokens) {
+    let Y = false;
+    for (let Z of K.tokens) {
+      if (Z.kind === "option-terminator") {
+        Y = true;
+        continue;
+      }
+      if (Z.kind === "positional")
+        (Y ? Q : L).push(Z.value ?? "");
+    }
+  } else
+    L.push(...K.positionals);
+  let X = h(z, K.values, H);
+  return { args: P(G, L), flags: X, rawArgs: Q };
+}
+function E(B, J) {
+  let { args: G, effectiveFlags: z } = B, j = J.args, H = J.flags;
+  if (G)
+    for (let K of G) {
+      let { name: Q } = K, L = `argument "<${Q}>"`, X = j[Q];
+      if (K.required === true && K.default === undefined) {
+        if (K.variadic) {
+          if (!Array.isArray(X) || X.length === 0)
+            throw new W("VALIDATION", `Missing required ${L}`);
+        } else if (X === undefined)
+          throw new W("VALIDATION", `Missing required ${L}`);
+      }
+    }
+  O(z, H);
+}
+var W;
+var init_chunk_vt64gs69 = __esm(() => {
+  W = class W extends Error {
+    code;
+    details;
+    cause;
+    constructor(B, J, ...G) {
+      super(J);
+      this.name = "CrustError", this.code = B, this.details = G[0];
+    }
+    is(B) {
+      return this.code === B;
+    }
+    withCause(B) {
+      return this.cause = B, this;
+    }
+  };
+});
+
+// ../../node_modules/.bun/@crustjs+core@0.0.16+7524df1edfed9f02/node_modules/@crustjs/core/dist/shared/chunk-5apf3vnv.js
+var exports_chunk_5apf3vnv = {};
+__export(exports_chunk_5apf3vnv, {
+  validateCommandTree: () => _2
+});
+function M2(B) {
+  switch (B.type) {
+    case "number":
+      return "1";
+    case "boolean":
+      return "true";
+    default:
+      return "sample";
+  }
+}
+function X(B) {
+  let z = [], K = B.effectiveFlags;
+  for (let [j, G] of Object.entries(K)) {
+    if (G.required !== true || G.default !== undefined)
+      continue;
+    if (z.push(`--${j}`), G.type !== "boolean")
+      z.push(M2(G));
+  }
+  let J = B.args;
+  if (J)
+    for (let j of J) {
+      if (j.required !== true || j.default !== undefined)
+        continue;
+      z.push(M2(j));
+    }
+  return z;
+}
+function _2(B) {
+  let z = [{ command: B, path: [B.meta.name] }], K = new Set;
+  while (z.length > 0) {
+    let J = z.pop();
+    if (!J)
+      break;
+    let { command: j, path: G } = J;
+    if (K.has(j))
+      continue;
+    K.add(j);
+    try {
+      let H = b(j, X(j));
+      E(j, H);
+    } catch (H) {
+      let L = H instanceof Error ? H.message : "Unknown validation error";
+      throw new W("DEFINITION", `Command "${G.join(" ")}" failed runtime validation: ${L}`).withCause(H);
+    }
+    for (let [H, L] of Object.entries(j.subCommands))
+      z.push({ command: L, path: [...G, H] });
+  }
+}
+var init_chunk_5apf3vnv = __esm(() => {
+  init_chunk_vt64gs69();
+});
+
+// ../../node_modules/.bun/@crustjs+core@0.0.16+7524df1edfed9f02/node_modules/@crustjs/core/dist/index.js
+init_chunk_vt64gs69();
+function T(j) {
+  return { meta: { name: j }, localFlags: {}, effectiveFlags: {}, args: undefined, subCommands: {}, plugins: [], preRun: undefined, run: undefined, postRun: undefined };
+}
+function z(j, q2) {
+  let J = {};
+  for (let [Q, $] of Object.entries(j))
+    if ($.inherit === true)
+      J[Q] = $;
+  for (let [Q, $] of Object.entries(q2))
+    J[Q] = $;
+  return J;
+}
+function D(j, q2) {
+  let J = [j.meta.name], Q = j, $ = q2;
+  while ($.length > 0) {
+    let K = Q.subCommands;
+    if (!K || Object.keys(K).length === 0)
+      break;
+    let Z = $[0];
+    if (!Z || Z.startsWith("-"))
+      break;
+    if (Z in K && K[Z]) {
+      Q = K[Z], J.push(Z), $ = $.slice(1);
+      continue;
+    }
+    if (Q.run)
+      break;
+    let H = Object.keys(K);
+    throw new W("COMMAND_NOT_FOUND", `Unknown command "${Z}".`, { input: Z, available: H, commandPath: [...J], parentCommand: Q });
+  }
+  return { command: Q, argv: $, commandPath: J };
+}
+function N(j) {
+  for (let [q2, J] of Object.entries(j)) {
+    if (q2.startsWith("no-")) {
+      let Q = q2.slice(3);
+      throw new W("DEFINITION", `Flag "--${q2}" must not use "no-" prefix; define "${Q}" and negate with "--no-${Q}"`);
+    }
+    if (J.short?.startsWith("no-"))
+      throw new W("DEFINITION", `Short alias "-${J.short}" on "--${q2}" must not use "no-" prefix (reserved for negation)`);
+    if (J.aliases) {
+      for (let Q of J.aliases)
+        if (Q.startsWith("no-"))
+          throw new W("DEFINITION", `Alias "--${Q}" on "--${q2}" must not use "no-" prefix (reserved for negation)`);
+    }
+  }
+}
+var w = "CRUST_INTERNAL_VALIDATE_ONLY";
+var P2 = 130;
+var v = "__CRUST_VALIDATE_RESULT__";
+function x() {
+  let j = new Map;
+  return { get(q2) {
+    return j.get(q2);
+  }, has(q2) {
+    return j.has(q2);
+  }, set(q2, J) {
+    j.set(q2, J);
+  }, delete(q2) {
+    return j.delete(q2);
+  } };
+}
+function B(j) {
+  if (!(j instanceof Error))
+    return false;
+  return j.name === "CancelledError";
+}
+function b2(j, q2) {
+  j.effectiveFlags = z(q2, j.localFlags);
+  for (let J of Object.values(j.subCommands))
+    b2(J, j.effectiveFlags);
+}
+function y(j) {
+  return { addFlag(q2, J, Q) {
+    if (J in q2.effectiveFlags)
+      j?.push(`Plugin flag "--${J}" on "${q2.meta.name}" overrides existing flag`);
+    q2.effectiveFlags[J] = Q;
+  }, addSubCommand(q2, J, Q) {
+    if (!J.trim())
+      throw new W("DEFINITION", "addSubCommand: name must be a non-empty string");
+    if (q2.subCommands[J]) {
+      j?.push(`Plugin subcommand "${J}" on "${q2.meta.name}" skipped (already exists)`);
+      return;
+    }
+    b2(Q, q2.effectiveFlags), q2.subCommands[J] = Q;
+  } };
+}
+async function A2(j, q2, J) {
+  for (let Q of j) {
+    if (!Q.setup)
+      continue;
+    await Q.setup(q2, J);
+  }
+}
+async function F(j, q2, J) {
+  let Q = j.map((Z) => Z.middleware).filter((Z) => Boolean(Z)), $ = -1, K = async (Z) => {
+    if (Z <= $)
+      throw new W("DEFINITION", "Plugin middleware called next() multiple times");
+    if ($ = Z, Z === Q.length) {
+      await J();
+      return;
+    }
+    let H = Q[Z];
+    if (!H)
+      throw new W("DEFINITION", "Plugin middleware stack is invalid");
+    await H(q2, () => K(Z + 1));
+  };
+  await K(0);
+}
+function I2(j) {
+  let q2 = [...j.plugins];
+  for (let J of Object.values(j.subCommands))
+    q2.push(...I2(J));
+  return q2;
+}
+function k(j) {
+  let q2 = {};
+  for (let [J, Q] of Object.entries(j))
+    q2[J] = { ...Q, aliases: Q.aliases ? [...Q.aliases] : undefined };
+  return q2;
+}
+function h2(j) {
+  let q2 = {};
+  for (let [J, Q] of Object.entries(j.subCommands))
+    q2[J] = h2(Q);
+  return { meta: { ...j.meta }, localFlags: k(j.localFlags), effectiveFlags: k(j.effectiveFlags), args: j.args ? j.args.map((J) => ({ ...J })) : undefined, subCommands: q2, plugins: [...j.plugins], preRun: j.preRun, run: j.run, postRun: j.postRun };
+}
+function _3(j) {
+  if (Object.freeze(j), Object.freeze(j.localFlags), Object.freeze(j.effectiveFlags), Object.freeze(j.meta), Object.freeze(j.plugins), j.args)
+    Object.freeze(j.args);
+  for (let q2 of Object.values(j.subCommands))
+    _3(q2);
+  Object.freeze(j.subCommands);
+}
+
+class R {
+  _node;
+  _inheritedFlags;
+  constructor(j) {
+    if (!j.trim())
+      throw new W("DEFINITION", "meta.name must be a non-empty string");
+    this._node = T(j), this._inheritedFlags = {};
+  }
+  static _createChild(j, q2) {
+    let J = new R(j);
+    return J._inheritedFlags = q2, J;
+  }
+  _clone(j) {
+    let q2 = Object.create(Object.getPrototypeOf(this)), J = { ...this._node, localFlags: { ...this._node.localFlags }, effectiveFlags: { ...this._node.effectiveFlags }, subCommands: { ...this._node.subCommands }, plugins: [...this._node.plugins], meta: { ...this._node.meta }, args: this._node.args ? [...this._node.args] : undefined, ...j };
+    return q2._node = J, q2._inheritedFlags = this._inheritedFlags, q2;
+  }
+  meta(j) {
+    return this._clone({ meta: { ...this._node.meta, ...j } });
+  }
+  flags(j) {
+    N(j);
+    let q2 = {};
+    for (let [J, Q] of Object.entries(j))
+      q2[J] = { ...Q };
+    return this._clone({ localFlags: q2, effectiveFlags: z(this._inheritedFlags, q2) });
+  }
+  args(j) {
+    let q2 = j.map((J) => ({ ...J }));
+    return this._clone({ args: q2 });
+  }
+  run(j) {
+    return this._clone({ run: j });
+  }
+  preRun(j) {
+    return this._clone({ preRun: j });
+  }
+  postRun(j) {
+    return this._clone({ postRun: j });
+  }
+  use(j) {
+    return this._clone({ plugins: [...this._node.plugins, j] });
+  }
+  sub(j) {
+    if (!j.trim())
+      throw new W("DEFINITION", "Subcommand name must be a non-empty string");
+    let q2 = z(this._inheritedFlags, this._node.localFlags);
+    return R._createChild(j, q2);
+  }
+  command(j, q2) {
+    if (typeof j === "string") {
+      let K = j;
+      if (!q2)
+        throw new W("DEFINITION", "command(name, cb) requires a callback");
+      if (!K.trim())
+        throw new W("DEFINITION", "Subcommand name must be a non-empty string");
+      if (this._node.subCommands[K])
+        throw new W("DEFINITION", `Subcommand "${K}" is already registered`);
+      let Z = z(this._inheritedFlags, this._node.localFlags), H = R._createChild(K, Z), X2 = q2(H), W2 = { ...X2._node, effectiveFlags: z(X2._inheritedFlags, X2._node.localFlags) };
+      return this._clone({ subCommands: { ...this._node.subCommands, [K]: W2 } });
+    }
+    let J = j, Q = J._node.meta.name;
+    if (!Q.trim())
+      throw new W("DEFINITION", "Subcommand name must be a non-empty string");
+    if (this._node.subCommands[Q])
+      throw new W("DEFINITION", `Subcommand "${Q}" is already registered`);
+    let $ = { ...J._node, effectiveFlags: z(J._inheritedFlags, J._node.localFlags) };
+    return this._clone({ subCommands: { ...this._node.subCommands, [Q]: $ } });
+  }
+  async prepareCommandTree(j) {
+    let q2 = j?.argv ?? [], J = h2(this._node), Q = I2(J), $ = [], K = x(), Z = { argv: [...q2], rootCommand: J, state: K }, H = y($);
+    try {
+      await A2(Q, Z, H);
+    } catch (W2) {
+      if (B(W2))
+        throw W2;
+      if (W2 instanceof W)
+        throw W2;
+      if (W2 instanceof Error)
+        throw W2;
+      throw new W("DEFINITION", String(W2));
+    }
+    _3(J);
+    let { validateCommandTree: X2 } = await Promise.resolve().then(() => (init_chunk_5apf3vnv(), exports_chunk_5apf3vnv));
+    return X2(J), { root: J, warnings: $ };
+  }
+  async execute(j) {
+    let q2 = j?.argv ?? process.argv.slice(2), J = this._node, Q = I2(J), $ = [], K = x(), Z = { argv: [...q2], rootCommand: J, state: K }, H = y($);
+    try {
+      await A2(Q, Z, H);
+    } catch (W2) {
+      if (B(W2)) {
+        process.exitCode = P2;
+        return;
+      }
+      if (W2 instanceof W) {
+        console.error(`Error: ${W2.message}`), process.exitCode = 1;
+        return;
+      }
+      let U2 = W2 instanceof Error ? W2.message : String(W2);
+      console.error(`Error: ${U2}`), process.exitCode = 1;
+      return;
+    }
+    if (_3(J), process.env[w] === "1") {
+      let W2 = (async () => {
+        try {
+          let { validateCommandTree: U2 } = await Promise.resolve().then(() => (init_chunk_5apf3vnv(), exports_chunk_5apf3vnv));
+          U2(J);
+          for (let Y of $)
+            console.warn(`Warning: ${Y}`);
+          return { ok: true };
+        } catch (U2) {
+          let Y = U2 instanceof Error ? U2.message : String(U2);
+          return console.error(Y), process.exitCode = 1, { ok: false, error: U2 };
+        }
+      })();
+      return globalThis[v] = W2, await W2, process.exit(process.exitCode ?? 0);
+    }
+    for (let W2 of $)
+      console.warn(`Warning: ${W2}`);
+    let X2 = { argv: [...q2], rootCommand: J, state: K, route: null, input: null };
+    try {
+      let W2, U2;
+      try {
+        let Y = D(J, [...q2]);
+        X2.route = Y, W2 = Y.command, U2 = b(W2, Y.argv), X2.input = U2;
+      } catch (Y) {
+        await F(Q, X2, async () => {
+          throw Y;
+        });
+        return;
+      }
+      await F(Q, X2, async () => {
+        if (E(W2, U2), !W2.run)
+          return;
+        let Y = { args: U2.args, flags: U2.flags, rawArgs: U2.rawArgs, command: W2 }, V;
+        try {
+          if (W2.preRun)
+            await W2.preRun(Y);
+          await W2.run(Y);
+        } catch (M3) {
+          V = M3;
+        }
+        if (W2.postRun)
+          try {
+            await W2.postRun(Y);
+          } catch (M3) {
+            if (!V)
+              V = M3;
+            else
+              console.error(`Error in postRun: ${M3 instanceof Error ? M3.message : String(M3)}`);
+          }
+        if (V)
+          throw V;
+      });
+    } catch (W2) {
+      if (B(W2)) {
+        process.exitCode = P2;
+        return;
+      }
+      if (W2 instanceof W) {
+        console.error(`Error: ${W2.message}`), process.exitCode = 1;
+        return;
+      }
+      if (W2 instanceof Error) {
+        let U2 = new W("EXECUTION", W2.message).withCause(W2);
+        console.error(`Error: ${U2.message}`), process.exitCode = 1;
+        return;
+      }
+      console.error(`Error: ${String(W2)}`), process.exitCode = 1;
+    }
+  }
+}
+
+// src/commands/scan.ts
+import { writeFileSync } from "fs";
+
+// src/sources/github.ts
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// src/errors.ts
+class CcpluginizerError extends Error {
+  name = "CcpluginizerError";
+}
+
+class AlreadyMarketplaceError extends CcpluginizerError {
+  repoPath;
+  name = "AlreadyMarketplaceError";
+  constructor(repoPath) {
+    super("This repo is already a marketplace; install via `/plugin marketplace add <repo>` directly. ccpluginizer is for non-plugin repos only.");
+    this.repoPath = repoPath;
+  }
+}
+
+class MarkerFileError extends CcpluginizerError {
+  issues;
+  name = "MarkerFileError";
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+  }
+}
+
+class PathNormalizationError extends CcpluginizerError {
+  invalidPath;
+  name = "PathNormalizationError";
+  constructor(invalidPath, reason) {
+    super(`Path "${invalidPath}" is invalid: ${reason}`);
+    this.invalidPath = invalidPath;
+  }
+}
+
+class SourceCloneError extends CcpluginizerError {
+  source;
+  name = "SourceCloneError";
+  constructor(source, cause) {
+    super(`Failed to fetch source "${source}": ${cause}`);
+    this.source = source;
+  }
+}
+
+// src/sources/github.ts
+async function resolveGithub(repo) {
+  const dest = mkdtempSync(join(tmpdir(), `ccp-${repo.replace("/", "-")}-`));
+  const url = `https://github.com/${repo}.git`;
+  const proc = Bun.spawn(["git", "clone", "--depth=1", url, dest], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new SourceCloneError(repo, stderr);
+  }
+  return dest;
+}
+
+// src/sources/index.ts
+function parseSourceInput(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../")) {
+    return { kind: "local", path: trimmed };
+  }
+  const httpsMatch = /^https:\/\/github\.com\/([^/]+\/[^/]+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (httpsMatch?.[1] !== undefined) {
+    return { kind: "github", repo: httpsMatch[1] };
+  }
+  const sshMatch = /^git@github\.com:([^/]+\/[^/]+?)(?:\.git)?$/.exec(trimmed);
+  if (sshMatch?.[1] !== undefined) {
+    return { kind: "github", repo: sshMatch[1] };
+  }
+  if (/^[\w.-]+\/[\w.-]+$/.test(trimmed)) {
+    return { kind: "github", repo: trimmed };
+  }
+  throw new Error(`Cannot parse source input: ${trimmed}`);
+}
+function inferSourceRepo(input) {
+  const parsed = parseSourceInput(input);
+  if (parsed.kind === "github") {
+    return parsed.repo;
+  }
+  const basename = parsed.path.split("/").filter(Boolean).pop() ?? "unknown";
+  return `local/${basename}`;
+}
+async function resolveSource(input) {
+  const parsed = parseSourceInput(input);
+  if (parsed.kind === "local") {
+    return parsed.path;
+  }
+  return resolveGithub(parsed.repo);
+}
+
+// src/detector/marketplaceGuard.ts
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+function checkMarketplaceGuard(repoRoot) {
+  const marketplaceFile = join2(repoRoot, ".claude-plugin", "marketplace.json");
+  if (existsSync(marketplaceFile)) {
+    throw new AlreadyMarketplaceError(repoRoot);
+  }
+}
+
+// src/detector/markerFile.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join3 } from "path";
+
+// ../../node_modules/.bun/valibot@1.3.1+7524df1edfed9f02/node_modules/valibot/dist/index.mjs
+var store$4;
+function getGlobalConfig(config$1) {
+  return {
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+  };
+}
+var store$3;
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
+}
+var store$2;
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
+}
+var store$1;
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
+}
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string")
+    return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean")
+    return `${input}`;
+  if (type === "object" || type === "function")
+    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== undefined)
+    issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema)
+    dataset.typed = false;
+  if (dataset.issues)
+    dataset.issues.push(issue);
+  else
+    dataset.issues = [issue];
+}
+function _getStandardProps(context) {
+  return {
+    version: 1,
+    vendor: "valibot",
+    validate(value$1) {
+      return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+    }
+  };
+}
+function _isValidObjectKey(object$1, key) {
+  return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+function _joinExpects(values$1, separator) {
+  const list = [...new Set(values$1)];
+  if (list.length > 1)
+    return `(${list.join(` ${separator} `)})`;
+  return list[0] ?? "never";
+}
+function regex(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "regex",
+    reference: regex,
+    async: false,
+    expects: `${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement.test(dataset.value))
+        _addIssue(this, "format", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function startsWith(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "starts_with",
+    reference: startsWith,
+    async: false,
+    expects: `"${requirement}"`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !dataset.value.startsWith(this.requirement))
+        _addIssue(this, "start", dataset, config$1, { received: `"${dataset.value.slice(0, this.requirement.length)}"` });
+      return dataset;
+    }
+  };
+}
+var _LruCache = class {
+  constructor(config$1) {
+    this.refCount = 0;
+    this.maxSize = config$1?.maxSize ?? 1000;
+    this.maxAge = config$1?.maxAge ?? Infinity;
+    this.hasMaxAge = isFinite(this.maxAge);
+  }
+  #stringify(input) {
+    const type = typeof input;
+    if (type === "string")
+      return `"${input}"`;
+    if (type === "number" || type === "boolean")
+      return `${input}`;
+    if (type === "bigint")
+      return `${input}n`;
+    if (type === "object" || type === "function") {
+      if (input) {
+        this.refIds ??= /* @__PURE__ */ new WeakMap;
+        let id = this.refIds.get(input);
+        if (!id) {
+          id = ++this.refCount;
+          this.refIds.set(input, id);
+        }
+        return `#${id}`;
+      }
+      return "null";
+    }
+    return type;
+  }
+  key(input, config$1 = {}) {
+    return `${this.#stringify(input)}|${this.#stringify(config$1.lang)}|${this.#stringify(config$1.message)}|${this.#stringify(config$1.abortEarly)}|${this.#stringify(config$1.abortPipeEarly)}`;
+  }
+  get(key) {
+    if (!this.store)
+      return;
+    const entry = this.store.get(key);
+    if (!entry)
+      return;
+    if (this.hasMaxAge && Date.now() - entry[1] > this.maxAge) {
+      this.store.delete(key);
+      return;
+    }
+    this.store.delete(key);
+    this.store.set(key, entry);
+    return entry[0];
+  }
+  set(key, value$1) {
+    this.store ??= /* @__PURE__ */ new Map;
+    this.store.delete(key);
+    const timestamp = this.hasMaxAge ? Date.now() : 0;
+    this.store.set(key, [value$1, timestamp]);
+    if (this.store.size > this.maxSize)
+      this.store.delete(this.store.keys().next().value);
+  }
+  clear() {
+    this.store?.clear();
+  }
+};
+function getFallback(schema, dataset, config$1) {
+  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+function getDefault(schema, dataset, config$1) {
+  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+function array(item, message$1) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0;key < input.length; key++) {
+          const value$1 = input[key];
+          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value$1
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path)
+                issue.path.unshift(pathItem);
+              else
+                issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues)
+              dataset.issues = itemDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed)
+            dataset.typed = false;
+          dataset.value.push(itemDataset.value);
+        }
+      } else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function boolean(message$1) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "boolean")
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function literal(literal_, message$1) {
+  return {
+    kind: "schema",
+    type: "literal",
+    reference: literal,
+    expects: /* @__PURE__ */ _stringify(literal_),
+    async: false,
+    literal: literal_,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === this.literal)
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function number(message$1) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value))
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function object(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== undefined) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path)
+                  issue.path.unshift(pathItem);
+                else
+                  issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues)
+                dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed)
+              dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== undefined)
+            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: undefined,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly)
+              break;
+          }
+        }
+      } else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === undefined) {
+        if (this.default !== undefined)
+          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === undefined) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+function record(key, value$1, message$1) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record,
+    expects: "Object",
+    async: false,
+    key,
+    value: value$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const entryKey in input)
+          if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+            const entryValue = input[entryKey];
+            const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
+            if (keyDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "key",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of keyDataset.issues) {
+                issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues)
+                dataset.issues = keyDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path)
+                  issue.path.unshift(pathItem);
+                else
+                  issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues)
+                dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!keyDataset.typed || !valueDataset.typed)
+              dataset.typed = false;
+            if (keyDataset.typed)
+              dataset.value[keyDataset.value] = valueDataset.value;
+          }
+      } else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function strictObject(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "strict_object",
+    reference: strictObject,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== undefined) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path)
+                  issue.path.unshift(pathItem);
+                else
+                  issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues)
+                dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed)
+              dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== undefined)
+            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: undefined,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly)
+              break;
+          }
+        }
+        if (!dataset.issues || !config$1.abortEarly) {
+          for (const key in input)
+            if (!(key in this.entries)) {
+              _addIssue(this, "key", dataset, config$1, {
+                input: key,
+                expected: "never",
+                path: [{
+                  type: "object",
+                  origin: "key",
+                  input,
+                  key,
+                  value: input[key]
+                }]
+              });
+              break;
+            }
+        }
+      } else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function string(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string")
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function _subIssues(datasets) {
+  let issues;
+  if (datasets)
+    for (const dataset of datasets)
+      if (issues)
+        issues.push(...dataset.issues);
+      else
+        issues = dataset.issues;
+  return issues;
+}
+function union(options, message$1) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
+        if (optionDataset.typed)
+          if (optionDataset.issues)
+            if (typedDatasets)
+              typedDatasets.push(optionDataset);
+            else
+              typedDatasets = [optionDataset];
+          else {
+            validDataset = optionDataset;
+            break;
+          }
+        else if (untypedDatasets)
+          untypedDatasets.push(optionDataset);
+        else
+          untypedDatasets = [optionDataset];
+      }
+      if (validDataset)
+        return validDataset;
+      if (typedDatasets) {
+        if (typedDatasets.length === 1)
+          return typedDatasets[0];
+        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+        dataset.typed = true;
+      } else if (untypedDatasets?.length === 1)
+        return untypedDatasets[0];
+      else
+        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+      return dataset;
+    }
+  };
+}
+function unknown() {
+  return {
+    kind: "schema",
+    type: "unknown",
+    reference: unknown,
+    expects: "unknown",
+    async: false,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+function pipe(...pipe$1) {
+  return {
+    ...pipe$1[0],
+    pipe: pipe$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      for (const item of pipe$1)
+        if (item.kind !== "metadata") {
+          if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+            dataset.typed = false;
+            break;
+          }
+          if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly)
+            dataset = item["~run"](dataset, config$1);
+        }
+      return dataset;
+    }
+  };
+}
+function safeParse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+
+// src/schemas/markerFile.ts
+var MarkerFileSchema = strictObject({
+  name: pipe(string(), regex(/^[a-z0-9][a-z0-9-]*$/)),
+  description: optional(string()),
+  skills: optional(array(pipe(string(), startsWith("./")))),
+  agents: optional(array(pipe(string(), startsWith("./")))),
+  commands: optional(array(pipe(string(), startsWith("./")))),
+  hooks: optional(string()),
+  mcpServers: optional(string()),
+  outputStyles: optional(array(pipe(string(), startsWith("./")))),
+  themes: optional(array(pipe(string(), startsWith("./")))),
+  monitors: optional(string()),
+  license: optional(string()),
+  homepage: optional(string()),
+  repository: optional(string())
+});
+
+// src/detector/markerFile.ts
+function detectMarkerFile(repoRoot) {
+  const markerPath = join3(repoRoot, ".ccpluginizer.json");
+  if (!existsSync2(markerPath)) {
+    return null;
+  }
+  const raw = readFileSync(markerPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new MarkerFileError(`Invalid JSON in ${markerPath}: ${e instanceof Error ? e.message : String(e)}`, []);
+  }
+  const result = safeParse(MarkerFileSchema, parsed);
+  if (!result.success) {
+    throw new MarkerFileError(`Marker file at ${markerPath} failed validation`, result.issues);
+  }
+  return result.output;
+}
+
+// src/detector/conventions.ts
+import { existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { join as join4 } from "path";
+var FOLDER_KINDS = [
+  { folder: "skills", kind: "skills" },
+  { folder: "agents", kind: "agents" },
+  { folder: "commands", kind: "commands" },
+  { folder: "output-styles", kind: "outputStyles" },
+  { folder: "themes", kind: "themes" }
+];
+var FILE_KINDS = [
+  { file: "hooks/hooks.json", kind: "hooks" },
+  { file: ".mcp.json", kind: "mcpServers" },
+  { file: "monitors/monitors.json", kind: "monitors" }
+];
+function detectConventions(repoRoot) {
+  const rootFindings = scanRoot(repoRoot, "");
+  const dotfilesFindings = scanRoot(repoRoot, ".claude");
+  return mergeByKind([...rootFindings, ...dotfilesFindings]);
+}
+function scanRoot(repoRoot, prefix) {
+  const findings = [];
+  const baseDir = prefix === "" ? repoRoot : join4(repoRoot, prefix);
+  const pathPrefix = prefix === "" ? "./" : `./${prefix}/`;
+  for (const { folder, kind } of FOLDER_KINDS) {
+    const folderPath = join4(baseDir, folder);
+    if (existsSync3(folderPath) && statSync(folderPath).isDirectory()) {
+      const hasContents = readdirSync(folderPath).length > 0;
+      findings.push({
+        kind,
+        paths: [`${pathPrefix}${folder}/`],
+        confidence: hasContents ? "high" : "medium",
+        source: "convention"
+      });
+    }
+  }
+  for (const { file, kind } of FILE_KINDS) {
+    if (existsSync3(join4(baseDir, file))) {
+      findings.push({
+        kind,
+        paths: [`${pathPrefix}${file}`],
+        confidence: "high",
+        source: "convention"
+      });
+    }
+  }
+  return findings;
+}
+function mergeByKind(findings) {
+  const byKind = new Map;
+  for (const finding of findings) {
+    const existing = byKind.get(finding.kind);
+    if (existing === undefined) {
+      byKind.set(finding.kind, finding);
+    } else {
+      const mergedPaths = [...new Set([...existing.paths, ...finding.paths])];
+      const mergedConfidence = existing.confidence === "high" || finding.confidence === "high" ? "high" : existing.confidence === "medium" || finding.confidence === "medium" ? "medium" : "low";
+      byKind.set(finding.kind, {
+        kind: finding.kind,
+        paths: mergedPaths,
+        confidence: mergedConfidence,
+        source: existing.source
+      });
+    }
+  }
+  return Array.from(byKind.values());
+}
+
+// src/detector/nonStandardManifest.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
+
+// src/schemas/nonStandardManifest.ts
+var NonStandardManifestSchema = object({
+  name: optional(string()),
+  description: optional(string()),
+  version: optional(string()),
+  author: optional(union([string(), object({ name: string() })])),
+  homepage: optional(string()),
+  repository: optional(string()),
+  license: optional(string()),
+  skills: optional(array(string())),
+  agents: optional(array(string())),
+  commands: optional(array(string())),
+  hooks: optional(string()),
+  mcpServers: optional(string())
+});
+
+// src/detector/nonStandardManifest.ts
+function detectNonStandardManifest(repoRoot) {
+  const dir = join5(repoRoot, ".claude-plugin");
+  if (!existsSync4(dir) || !statSync2(dir).isDirectory()) {
+    return null;
+  }
+  for (const entry of readdirSync2(dir)) {
+    if (entry === "plugin.json" || entry === "marketplace.json") {
+      continue;
+    }
+    if (!entry.endsWith(".json")) {
+      continue;
+    }
+    const filePath = join5(dir, entry);
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync2(filePath, "utf8"));
+    } catch {
+      continue;
+    }
+    const result = safeParse(NonStandardManifestSchema, parsed);
+    if (!result.success) {
+      continue;
+    }
+    const m = result.output;
+    const hasComponent = m.skills !== undefined || m.agents !== undefined || m.commands !== undefined || m.hooks !== undefined || m.mcpServers !== undefined;
+    if (!hasComponent) {
+      continue;
+    }
+    return { filename: entry, manifest: m };
+  }
+  return null;
+}
+
+// src/detector/contentSniff.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { join as join6, dirname, relative } from "path";
+
+// src/schemas/frontmatter.ts
+var SkillFrontmatterSchema = object({
+  name: optional(string()),
+  description: string(),
+  "disable-model-invocation": optional(boolean())
+});
+var AgentFrontmatterSchema = object({
+  name: string(),
+  description: string(),
+  model: optional(string()),
+  effort: optional(string()),
+  maxTurns: optional(number()),
+  tools: optional(array(string())),
+  disallowedTools: optional(union([string(), array(string())]))
+});
+
+// src/detector/contentSniff.ts
+function detectContentSniff(repoRoot) {
+  const skillDirs = new Set;
+  const agentFiles = new Set;
+  walk(repoRoot, repoRoot, (filePath) => {
+    if (filePath.endsWith("SKILL.md")) {
+      const fm = parseFrontmatter(filePath);
+      if (fm !== null && safeParse(SkillFrontmatterSchema, fm).success) {
+        const dir = dirname(filePath);
+        skillDirs.add(dir);
+      }
+      return;
+    }
+    if (filePath.endsWith(".md")) {
+      const fm = parseFrontmatter(filePath);
+      if (fm !== null && safeParse(AgentFrontmatterSchema, fm).success) {
+        agentFiles.add(filePath);
+      }
+    }
+  });
+  const findings = [];
+  if (skillDirs.size > 0) {
+    findings.push({
+      kind: "skills",
+      paths: Array.from(skillDirs).map((dir) => `./${relative(repoRoot, dir)}/`),
+      confidence: "medium",
+      source: "sniff"
+    });
+  }
+  if (agentFiles.size > 0) {
+    findings.push({
+      kind: "agents",
+      paths: Array.from(agentFiles).map((file) => `./${relative(repoRoot, file)}`),
+      confidence: "medium",
+      source: "sniff"
+    });
+  }
+  return findings;
+}
+function walk(repoRoot, dir, visit) {
+  for (const entry of readdirSync3(dir)) {
+    if (entry === "node_modules" || entry === ".git") {
+      continue;
+    }
+    const fullPath = join6(dir, entry);
+    const s = statSync3(fullPath);
+    if (s.isDirectory()) {
+      walk(repoRoot, fullPath, visit);
+    } else if (s.isFile()) {
+      visit(fullPath);
+    }
+  }
+}
+function parseFrontmatter(filePath) {
+  const content = readFileSync3(filePath, "utf8");
+  const match = /^---\n([\s\S]*?)\n---/.exec(content);
+  if (match === null) {
+    return null;
+  }
+  const yamlBody = match[1];
+  if (yamlBody === undefined) {
+    return null;
+  }
+  return parseYamlBlock(yamlBody);
+}
+function parseYamlBlock(body) {
+  const out = {};
+  for (const line of body.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      continue;
+    }
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, colonIdx).trim();
+    const rawValue = trimmed.slice(colonIdx + 1).trim();
+    out[key] = coerceYamlValue(rawValue);
+  }
+  return out;
+}
+function coerceYamlValue(raw) {
+  if (raw === "true")
+    return true;
+  if (raw === "false")
+    return false;
+  if (raw === "null" || raw === "~")
+    return null;
+  if (/^-?\d+$/.test(raw))
+    return Number(raw);
+  if (raw.startsWith('"') && raw.endsWith('"'))
+    return raw.slice(1, -1);
+  if (raw.startsWith("'") && raw.endsWith("'"))
+    return raw.slice(1, -1);
+  return raw;
+}
+
+// src/detector/normalize.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join7 } from "path";
+function normalizePath(input) {
+  if (input.split("/").includes("..")) {
+    throw new PathNormalizationError(input, "path traversal (..) not allowed");
+  }
+  if (input.startsWith("/") || input.startsWith("~")) {
+    throw new PathNormalizationError(input, "absolute paths not allowed");
+  }
+  if (/^[A-Za-z]:[/\\]/.test(input)) {
+    throw new PathNormalizationError(input, "windows-style absolute paths not allowed");
+  }
+  if (input.startsWith("./")) {
+    return input;
+  }
+  return `./${input}`;
+}
+function normalizePathsAgainstRepo(repoRoot, paths) {
+  const kept = [];
+  const dropped = [];
+  for (const raw of paths) {
+    const normalized = normalizePath(raw);
+    const fullPath = join7(repoRoot, normalized);
+    if (existsSync5(fullPath)) {
+      kept.push(normalized);
+    } else {
+      dropped.push(normalized);
+    }
+  }
+  return { kept, dropped };
+}
+
+// src/detector/synthesize.ts
+function synthesizeEntry(input) {
+  checkMarketplaceGuard(input.repoRoot);
+  const marker = detectMarkerFile(input.repoRoot);
+  if (marker !== null) {
+    return buildEntryFromMarker(marker, input.sourceRepo, input.repoRoot);
+  }
+  const conventionFindings = detectConventions(input.repoRoot);
+  const manifestResult = detectNonStandardManifest(input.repoRoot);
+  const sniffFindings = detectContentSniff(input.repoRoot);
+  const findings = [...conventionFindings];
+  const manifestKindsWithFindings = new Set;
+  if (manifestResult !== null) {
+    addManifestFindings(findings, manifestResult.manifest, manifestKindsWithFindings);
+  }
+  let mergedFindings = findings.filter((f) => {
+    if (f.source === "convention" && manifestKindsWithFindings.has(f.kind)) {
+      return false;
+    }
+    return true;
+  });
+  for (const sniffF of sniffFindings) {
+    if (!hasKind(mergedFindings, sniffF.kind)) {
+      mergedFindings = [...mergedFindings, sniffF];
+    }
+  }
+  const entry = buildEntryFromFindings(mergedFindings, input.repoRoot, input.sourceRepo);
+  if (manifestResult !== null) {
+    return mergeManifestMetadata(entry, manifestResult.manifest);
+  }
+  return entry;
+}
+function addManifestFindings(findings, manifest, manifestKindsWithFindings) {
+  const kinds = [
+    { key: "skills", kind: "skills" },
+    { key: "agents", kind: "agents" },
+    { key: "commands", kind: "commands" }
+  ];
+  for (const { key, kind } of kinds) {
+    const value = manifest[key];
+    if (Array.isArray(value)) {
+      findings.push({
+        kind,
+        paths: value,
+        confidence: "high",
+        source: "manifest"
+      });
+      manifestKindsWithFindings.add(kind);
+    }
+  }
+}
+function mergeManifestMetadata(entry, manifest) {
+  return {
+    ...entry,
+    ...manifest.description !== undefined ? { description: manifest.description } : {},
+    ...manifest.homepage !== undefined ? { homepage: manifest.homepage } : {},
+    ...manifest.repository !== undefined ? { repository: manifest.repository } : {},
+    ...manifest.license !== undefined ? { license: manifest.license } : {},
+    ...manifest.author !== undefined ? { author: manifest.author } : {}
+  };
+}
+function buildEntryFromMarker(marker, sourceRepo, repoRoot) {
+  const normalizeIfPresent = (paths) => {
+    if (paths === undefined) {
+      return;
+    }
+    const { kept } = normalizePathsAgainstRepo(repoRoot, paths);
+    return kept.length > 0 ? [...kept] : undefined;
+  };
+  const skills = normalizeIfPresent(marker.skills);
+  const agents = normalizeIfPresent(marker.agents);
+  const commands = normalizeIfPresent(marker.commands);
+  const outputStyles = normalizeIfPresent(marker.outputStyles);
+  const themes = normalizeIfPresent(marker.themes);
+  return {
+    name: marker.name,
+    source: makeGithubSource(sourceRepo),
+    strict: false,
+    ...marker.description !== undefined ? { description: marker.description } : {},
+    ...marker.license !== undefined ? { license: marker.license } : {},
+    ...marker.homepage !== undefined ? { homepage: marker.homepage } : {},
+    ...marker.repository !== undefined ? { repository: marker.repository } : {},
+    ...skills !== undefined ? { skills } : {},
+    ...agents !== undefined ? { agents } : {},
+    ...commands !== undefined ? { commands } : {},
+    ...marker.hooks !== undefined ? { hooks: marker.hooks } : {},
+    ...marker.mcpServers !== undefined ? { mcpServers: marker.mcpServers } : {},
+    ...outputStyles !== undefined ? { outputStyles } : {},
+    ...themes !== undefined ? { themes } : {},
+    ...marker.monitors !== undefined ? { monitors: marker.monitors } : {}
+  };
+}
+function buildEntryFromFindings(findings, repoRoot, sourceRepo) {
+  const byKind = groupByKind(findings);
+  const componentEntries = {};
+  for (const [kind, kindFindings] of byKind) {
+    const allPaths = kindFindings.flatMap((f) => f.paths);
+    const { kept } = normalizePathsAgainstRepo(repoRoot, allPaths);
+    if (kept.length > 0) {
+      componentEntries[kind] = kept;
+    }
+  }
+  return {
+    name: defaultEntryName(sourceRepo),
+    source: makeGithubSource(sourceRepo),
+    strict: false,
+    ...componentEntries
+  };
+}
+function hasKind(findings, kind) {
+  for (const f of findings) {
+    if (f.kind === kind) {
+      return true;
+    }
+  }
+  return false;
+}
+function groupByKind(findings) {
+  const map = new Map;
+  for (const f of findings) {
+    const list = map.get(f.kind) ?? [];
+    list.push(f);
+    map.set(f.kind, list);
+  }
+  return map;
+}
+function makeGithubSource(repo) {
+  return { source: "github", repo };
+}
+function defaultEntryName(sourceRepo) {
+  return sourceRepo.replace("/", "-").toLowerCase();
+}
+
+// src/commands/scan.ts
+var scanCommand = new R("scan").meta({ description: "Scan a non-plugin repo and emit a marketplace entry" }).args([{ name: "repo", type: "string", required: true, description: "owner/repo, URL, or local path" }]).flags({
+  output: { type: "string", short: "o", description: "Write entry JSON to file" }
+}).run(async ({ args, flags }) => {
+  const repoPath = await resolveSource(args.repo);
+  const sourceRepo = inferSourceRepo(args.repo);
+  const entry = synthesizeEntry({ repoRoot: repoPath, sourceRepo });
+  const json = JSON.stringify(entry, null, 2);
+  if (flags.output !== undefined) {
+    writeFileSync(flags.output, json + `
+`, "utf8");
+  } else {
+    console.log(json);
+  }
+});
+
+// src/commands/validate.ts
+import { readFileSync as readFileSync4 } from "fs";
+
+// src/schemas/marketplaceEntry.ts
+var PathString = pipe(string(), startsWith("./"));
+var GithubSourceSchema = strictObject({
+  source: literal("github"),
+  repo: pipe(string(), regex(/^[\w.-]+\/[\w.-]+$/)),
+  ref: optional(string()),
+  sha: optional(string())
+});
+var UrlSourceSchema = strictObject({
+  source: literal("url"),
+  url: string(),
+  ref: optional(string()),
+  sha: optional(string())
+});
+var GitSubdirSourceSchema = strictObject({
+  source: literal("git-subdir"),
+  url: string(),
+  path: string(),
+  ref: optional(string()),
+  sha: optional(string())
+});
+var SourceSchema = union([GithubSourceSchema, UrlSourceSchema, GitSubdirSourceSchema]);
+var MarketplaceEntrySchema = object({
+  name: pipe(string(), regex(/^[a-z0-9][a-z0-9-]*$/)),
+  source: SourceSchema,
+  strict: optional(boolean()),
+  description: optional(string()),
+  version: optional(string()),
+  author: optional(union([string(), object({ name: string() })])),
+  homepage: optional(string()),
+  repository: optional(string()),
+  license: optional(string()),
+  keywords: optional(array(string())),
+  skills: optional(array(PathString)),
+  agents: optional(array(PathString)),
+  commands: optional(array(PathString)),
+  hooks: optional(union([PathString, record(string(), unknown())])),
+  mcpServers: optional(union([PathString, record(string(), unknown())])),
+  outputStyles: optional(array(PathString)),
+  themes: optional(array(PathString)),
+  monitors: optional(PathString)
+});
+
+// src/commands/validate.ts
+var validateCommand = new R("validate").meta({ description: "Validate a marketplace entry JSON file against the schema" }).args([{ name: "entryFile", type: "string", required: true, description: "Path to entry JSON file" }]).run(({ args }) => {
+  const raw = readFileSync4(args.entryFile, "utf8");
+  const parsed = JSON.parse(raw);
+  const result = safeParse(MarketplaceEntrySchema, parsed);
+  if (!result.success) {
+    console.error("Validation failed:");
+    for (const issue of result.issues) {
+      console.error(JSON.stringify(issue));
+    }
+    process.exit(1);
+  }
+  console.log("OK");
+});
+
+// src/commands/submit.ts
+import { writeFileSync as writeFileSync2, mkdtempSync as mkdtempSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join8 } from "path";
+var submitCommand = new R("submit").meta({ description: "Generate an entry and open a PR against ccpluginizer/marketplace" }).args([{ name: "repo", type: "string", required: true, description: "owner/repo to pluginize" }]).flags({
+  dryRun: { type: "boolean", short: "n", description: "Print the PR plan without opening it" }
+}).run(async ({ args, flags }) => {
+  const repoPath = await resolveSource(args.repo);
+  const sourceRepo = inferSourceRepo(args.repo);
+  const entry = synthesizeEntry({ repoRoot: repoPath, sourceRepo });
+  const tmpFile = join8(mkdtempSync2(join8(tmpdir2(), "ccp-submit-")), `${entry.name}.json`);
+  writeFileSync2(tmpFile, JSON.stringify(entry, null, 2) + `
+`, "utf8");
+  if (flags.dryRun === true) {
+    console.log(`Would submit:
+  entry: ${tmpFile}
+  to:    ccpluginizer/marketplace`);
+    console.log(JSON.stringify(entry, null, 2));
+    return;
+  }
+  console.log(`Generated entry at ${tmpFile}`);
+  console.log("Run with --dryRun to preview, or follow the manual PR workflow in CONTRIBUTING.md.");
+});
+
+// src/index.ts
+var app = new R("ccpluginizer").meta({ description: "Pluginize non-plugin Claude Code repos" }).command(scanCommand).command(validateCommand).command(submitCommand);
+await app.execute();