@skaile/workspaces 1.4.0 → 1.6.0

package/dist/chunk-WYGXYGJH.js

@@ -0,0 +1,688 @@
+import { openLibraryManager, createFullRegistry } from './chunk-RSYV7XEN.js';
+import { logErr, logInfo, logWarn, logOk, S } from './chunk-KMY7HVQ6.js';
+import { getStoreManifestsDir, LocalCatalogSource, writeCuratedManifest } from './chunk-FDE7XRQA.js';
+import { computeDeterministicHash, discoverAssetsInTree } from './chunk-MZV6WCF3.js';
+import { WorkspaceYamlEditor } from './chunk-HY33RMEA.js';
+import { findWorkspaceRoot, workspaceConfigFilename, sourceShortName, sourceCacheKey, storeManifestSlug, getGlobalCacheDir, resolveSourcePublisher } from './chunk-UQKYT4V6.js';
+import { decodeSkaileManifest, encodeSkaileManifest } from './chunk-P4VHQA4N.js';
+import { parseAssetRef } from './chunk-GEEW6SY2.js';
+import { spawnSync } from 'child_process';
+import { existsSync, rmSync, renameSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import * as path from 'path';
+import * as p from '@clack/prompts';
+import { Command } from 'commander';
+
+var NOT_WIRED_MSG = "`skaile source manifest *` is scaffolded but not yet wired. Server-side endpoint (`POST /sources/<id>/manifest`) lands in a follow-up PR.";
+function notWired(verb) {
+  logErr(`${NOT_WIRED_MSG} (verb: source manifest ${verb})`);
+  process.exit(2);
+}
+function resolveSourceArg(arg, projectDir) {
+  const root = findWorkspaceRoot(projectDir);
+  const registered = root ? readProjectSources(path.join(root, workspaceConfigFilename())) : [];
+  const match = registered.find((e) => sourceMatchesKey(e, arg));
+  const bySlug = !match ? resolveByStoreSlug(arg) : void 0;
+  const url = match ? match.url : bySlug?.url ?? normalizeSourceUrl(arg);
+  const slug = sourceShortName(url);
+  const dest = sourceClonePath(sourceCacheKey(url));
+  return { url, slug, dest, manifestFile: bySlug?.manifestFile ?? storeManifestPath(url) };
+}
+function resolveByStoreSlug(arg) {
+  if (!/^[\w.-]+__[\w.-]+/.test(arg) || /[/:\\]/.test(arg)) return void 0;
+  const manifestFile = path.join(getStoreManifestsDir(), `${arg}.yaml`);
+  if (!existsSync(manifestFile)) return void 0;
+  const [host, owner, repo] = arg.split("__");
+  const url = host && owner && repo ? `https://${host}/${owner}/${repo}` : arg;
+  return { url, manifestFile };
+}
+function storeManifestPath(url) {
+  return path.join(getStoreManifestsDir(), `${storeManifestSlug(url)}.yaml`);
+}
+var TEST_FIXTURE_SEGMENTS = /* @__PURE__ */ new Set([
+  "tests",
+  "test",
+  "__tests__",
+  "testdata",
+  "fixtures",
+  "__fixtures__"
+]);
+function isTestFixtureAsset(relativePath) {
+  const segments = relativePath.replace(/\\/g, "/").split("/");
+  return segments.some((s) => TEST_FIXTURE_SEGMENTS.has(s));
+}
+async function runInit(arg, opts) {
+  const projectDir = path.resolve(opts.projectDir);
+  const { url, dest, manifestFile: target } = resolveSourceArg(arg, projectDir);
+  if (existsSync(target) && !opts.force) {
+    logWarn(
+      `A curated manifest already exists at ${S.dim(target)}. Edit it with \`skaile source manifest edit\`, refresh it after an upstream change with \`skaile source manifest rebuild\`, or pass --force to regenerate.`
+    );
+    return;
+  }
+  const entry = { url };
+  ensureClone(entry);
+  const { assets, errors } = discoverCuratableAssets(dest, opts.dev ?? false);
+  const publisher = opts.publisher ?? resolveSourcePublisher(dest) ?? sourceShortName(url);
+  const written = writeCuratedManifest({
+    manifestFile: target,
+    publisher,
+    assets,
+    force: opts.force,
+    // Init: every asset inherits the top-level repo `publisher`. Do NOT stamp a
+    // per-asset publisher — on the glob path each DiscoveredAsset.publisher is
+    // the bare first path segment (`scripts`/`skills`/…), which would clobber
+    // the intended org/`--publisher` default with junk per-asset overrides.
+    inheritPublisher: true
+  });
+  if (!written.wrote) {
+    logWarn(
+      `Curated manifest already exists at ${S.dim(target)} \u2014 not overwritten. Pass --force to regenerate.`
+    );
+    return;
+  }
+  logOk(`Wrote curated manifest with ${written.assetCount} assets to ${S.dim(target)}.`);
+  logInfo(
+    `Edit it with \`skaile source manifest edit ${arg}\`, then \`skaile source add ${arg}\` to consume it.`
+  );
+  if (errors.length > 0) {
+    logWarn(`${errors.length} discovery error(s) \u2014 inspect the manifest before consuming.`);
+  }
+}
+function discoverCuratableAssets(dest, includeDev) {
+  const result = discoverAssetsInTree(dest, {
+    registry: createFullRegistry(),
+    includeDev
+  });
+  const assets = result.assets.filter((a) => !isTestFixtureAsset(a.relativePath));
+  return { assets, errors: result.errors.map((e) => `${e.path}: ${e.error}`) };
+}
+function pullCloneFfOnly(dest) {
+  const res = spawnSync("git", ["-C", dest, "pull", "--ff-only"], { stdio: "pipe" });
+  if (res.status !== 0) {
+    logWarn(
+      "git pull --ff-only failed \u2014 continuing with the existing clone (it may be behind upstream)."
+    );
+  }
+}
+function entryRootKey(entry) {
+  if (entry.root) return entry.root.replace(/\\/g, "/").replace(/\/+$/, "");
+  const files = entry.files;
+  if (files && files.length > 0) {
+    const first = typeof files[0] === "string" ? files[0] : files[0].path;
+    const dir = path.posix.dirname(first.replace(/\\/g, "/"));
+    return dir === "." ? entry.name : dir;
+  }
+  return entry.name;
+}
+function discoveredRootKey(relativePath) {
+  const dir = path.posix.dirname(relativePath.replace(/\\/g, "/"));
+  return dir === "." ? path.posix.basename(relativePath.replace(/\\/g, "/")) : dir;
+}
+function entryRef(entry) {
+  return `${entry.kind}:${entry.name}`;
+}
+async function runRebuild(arg, opts) {
+  const projectDir = path.resolve(opts.projectDir);
+  const { url, dest, slug, manifestFile: target } = resolveSourceArg(arg, projectDir);
+  if (!existsSync(target)) {
+    logErr(
+      `No curated manifest for "${slug}" at ${S.dim(target)} \u2014 run \`skaile source manifest init\` first.`
+    );
+    process.exit(1);
+  }
+  const entry = { url };
+  const cloned = ensureClone(entry);
+  if (!cloned) pullCloneFfOnly(dest);
+  const { assets: freshAssets, errors } = discoverCuratableAssets(dest, opts.dev ?? false);
+  if (opts.overwrite) {
+    logWarn(
+      "--overwrite: replacing the curated manifest with a full fresh inventory. All hand-curation (dropped assets, per-asset edits) is discarded."
+    );
+    const publisher = opts.publisher ?? resolveSourcePublisher(dest) ?? sourceShortName(url);
+    const written = writeCuratedManifest({
+      manifestFile: target,
+      publisher,
+      assets: freshAssets,
+      force: true,
+      inheritPublisher: true
+    });
+    logOk(
+      `Rebuilt curated manifest with ${written.assetCount} assets to ${S.dim(target)} (overwrite).`
+    );
+    if (errors.length > 0) {
+      logWarn(`${errors.length} discovery error(s) \u2014 inspect the manifest before consuming.`);
+    }
+    return;
+  }
+  if (opts.publisher) {
+    logWarn(
+      "--publisher is ignored in merge mode (the curated publisher is preserved). Use --overwrite to re-derive the publisher from a full re-scan."
+    );
+  }
+  const { manifest: existing } = decodeSkaileManifest(readFileSync(target, "utf-8"));
+  const existingEntries = existing.assets ?? [];
+  const freshByRoot = /* @__PURE__ */ new Map();
+  for (const a of freshAssets) freshByRoot.set(discoveredRootKey(a.relativePath), a);
+  const kept = [];
+  const dropped = [];
+  for (const e of existingEntries) {
+    if (freshByRoot.has(entryRootKey(e))) kept.push(e);
+    else dropped.push(entryRef(e));
+  }
+  const existingRoots = new Set(existingEntries.map(entryRootKey));
+  const newlyAvailable = [];
+  for (const a of freshAssets) {
+    if (!existingRoots.has(discoveredRootKey(a.relativePath))) {
+      newlyAvailable.push(`${a.kind}:${a.name}`);
+    }
+  }
+  const changed = dropped.length > 0;
+  if (dropped.length > 0) {
+    logWarn(`removed (gone upstream): ${dropped.sort().join(", ")}`);
+  }
+  if (newlyAvailable.length > 0) {
+    logInfo(
+      `${newlyAvailable.length} new upstream asset(s) available (not added): ${newlyAvailable.sort().join(", ")} \u2014 add with \`skaile source manifest edit ${arg}\` if wanted`
+    );
+  }
+  if (!changed) {
+    logOk("already up to date");
+    if (errors.length > 0) {
+      logWarn(`${errors.length} discovery error(s) \u2014 inspect the source before re-consuming.`);
+    }
+    return;
+  }
+  const merged = { ...existing, assets: kept };
+  writeFileSync(target, encodeSkaileManifest(merged), "utf-8");
+  logOk(
+    `Rebuilt curated manifest: kept ${kept.length}, dropped ${dropped.length} \u2192 ${S.dim(target)}.`
+  );
+  if (errors.length > 0) {
+    logWarn(`${errors.length} discovery error(s) \u2014 inspect the source before re-consuming.`);
+  }
+}
+async function runVerify(arg, opts) {
+  const projectDir = path.resolve(opts.projectDir);
+  const { url, dest, slug, manifestFile: target } = resolveSourceArg(arg, projectDir);
+  if (!existsSync(target)) {
+    logErr(
+      `No curated manifest for "${slug}" at ${S.dim(target)} \u2014 run \`skaile source manifest init\` first.`
+    );
+    process.exit(1);
+  }
+  ensureClone({ url });
+  const text = readFileSync(target, "utf-8");
+  const { manifest, diagnostics } = decodeSkaileManifest(text);
+  const errors = [];
+  const warnings = [];
+  for (const d of diagnostics) {
+    const line = `${d.code}: ${d.message}`;
+    if (d.severity === "error") errors.push(line);
+    else warnings.push(line);
+  }
+  const assets = manifest.assets ?? [];
+  for (const entry of assets) {
+    const ref = entryRef(entry);
+    const relPaths = [];
+    if (entry.root) relPaths.push(entry.root);
+    if (entry.files) {
+      for (const f of entry.files) relPaths.push(typeof f === "string" ? f : f.path);
+    }
+    if (relPaths.length === 0) relPaths.push(entry.name);
+    for (const rel of relPaths) {
+      if (!existsSync(path.join(dest, rel))) {
+        errors.push(`${ref}: path not found upstream: ${rel}`);
+      }
+    }
+    if (entry.sha256) {
+      if (entry.files && entry.files.length > 0) {
+        const hashFiles = entry.files.map(
+          (f) => (typeof f === "string" ? f : f.path).replace(/\\/g, "/")
+        );
+        const actual = computeDeterministicHash(dest, hashFiles);
+        if (actual !== entry.sha256) {
+          errors.push(
+            `${ref}: sha256 mismatch (declared ${entry.sha256.slice(0, 12)}\u2026, got ${actual.slice(0, 12)}\u2026)`
+          );
+        }
+      } else {
+        warnings.push(
+          `${ref}: declared sha256 on a root:-mode entry is not verifiable (discovery hashes only the per-kind filtered set) \u2014 skipped`
+        );
+      }
+    }
+    for (const dep of entry.dependencies ?? []) {
+      try {
+        parseAssetRef(dep);
+      } catch (err) {
+        warnings.push(
+          `${ref}: malformed dependency "${dep}": ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  for (const w of warnings) logWarn(w);
+  for (const e of errors) logErr(e);
+  if (errors.length === 0) {
+    logOk(`verified ${assets.length} asset(s).`);
+  } else {
+    logErr(`${errors.length} issue(s).`);
+  }
+  const failStrict = opts.strict && warnings.length > 0;
+  if (errors.length > 0 || failStrict) process.exit(1);
+}
+function resolveEditorCommand(editorEnv, target) {
+  const parts = (editorEnv ?? "").trim().split(/\s+/).filter(Boolean);
+  const [command, ...rest] = parts.length > 0 ? parts : ["vi"];
+  return { command, args: [...rest, target] };
+}
+function runEdit(arg, opts, spawn = spawnSync) {
+  const projectDir = path.resolve(opts.projectDir);
+  const { slug, manifestFile: target } = resolveSourceArg(arg, projectDir);
+  if (!existsSync(target)) {
+    logErr(
+      `No curated manifest for "${slug}" at ${target}. Run \`skaile source manifest init\` first.`
+    );
+    process.exit(1);
+  }
+  const { command, args } = resolveEditorCommand(process.env.VISUAL || process.env.EDITOR, target);
+  const res = spawn(command, args, { stdio: "inherit" });
+  if (res.status !== 0 && res.status !== null) {
+    logErr(`Editor exited with status ${res.status}.`);
+    process.exit(1);
+  }
+  const { diagnostics } = decodeSkaileManifest(readFileSync(target, "utf-8"));
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  const warnings = diagnostics.filter((d) => d.severity !== "error");
+  if (errors.length > 0) {
+    for (const d of errors) logErr(`${d.code}: ${d.message}`);
+    logWarn("Manifest has errors \u2014 fix them before `skaile source add` will consume it.");
+  } else if (warnings.length > 0) {
+    for (const d of warnings) logWarn(`${d.code}: ${d.message}`);
+    logOk("Saved (with warnings).");
+  } else {
+    logOk("Saved.");
+  }
+}
+function addSourceManifestCommands(src) {
+  const manifest = src.command("manifest").description("Curated manifest lifecycle for a source").enablePositionalOptions();
+  manifest.command("init <src>").description("Generate a curated manifest for a source (stored in the local store catalog)").option("-C, --project-dir <dir>", "Project directory", process.cwd()).option("--publisher <name>", "Override the publisher (default: source's GitHub org)").option("--dev", "Include assets under the source's dev_paths", false).option("--force", "Overwrite an existing curated manifest", false).action((arg, opts) => runInit(arg, opts));
+  manifest.command("edit <src>").description("Open the curated manifest in $EDITOR and re-validate on save").option("-C, --project-dir <dir>", "Project directory", process.cwd()).action((arg, opts) => runEdit(arg, opts));
+  manifest.command("rebuild <src>").description(
+    "Refresh a curated manifest after an upstream change (merge by default: keeps curation, drops assets gone upstream, reports new ones without adding)"
+  ).option("-C, --project-dir <dir>", "Project directory", process.cwd()).option("--publisher <name>", "Override the publisher (--overwrite only)").option("--dev", "Include assets under the source's dev_paths", false).option("--overwrite", "Discard curation and re-scan the full inventory", false).action((arg, opts) => runRebuild(arg, opts));
+  manifest.command("verify <src>").description("Verify hashes, deps, and schema (read-only)").option("-C, --project-dir <dir>", "Project directory", process.cwd()).option("--strict", "Fail on advisory checks (warnings force a nonzero exit)", false).action((arg, opts) => runVerify(arg, opts));
+  manifest.command("publish <src>").description("Push the curated sidecar manifest and publish it to the store").option("-C, --project-dir <dir>", "Project directory", process.cwd()).option("--as <namespace>", "Publisher namespace (default: your store username)").option("--sidecar-repo <url>", "Public GitHub repo you own to hold the curated manifest").option("--ref <gitref>", "Foreign source ref to ingest (branch/sha; default: main)").option("--dry-run", "Print the publish plan without pushing or calling the store", false).action(async (arg, opts) => {
+    const { runPublish } = await import('./source-manifest-publish-TGVZ6KMC.js');
+    await runPublish(arg, opts);
+  });
+  manifest.command("propose <src>").description("Open a PR to upstream with the sidecar manifest").action(() => notWired("propose"));
+  manifest.command("yank <src>").description("Retract the source's published assets from the store").option("-C, --project-dir <dir>", "Project directory", process.cwd()).option("--asset <ref>", "Yank only the asset matching this ref/name").action(async (arg, opts) => {
+    const { runYank } = await import('./source-manifest-publish-TGVZ6KMC.js');
+    await runYank(arg, opts);
+  });
+}
+
+// cli/src/commands/source.ts
+function sourceClonePath(key) {
+  return path.join(getGlobalCacheDir(), key);
+}
+var SKAILE_MANIFEST_FILENAME = "skaile.manifest.yaml";
+var LEGACY_SOURCE_CONFIG_FILENAME = ".skaile-source.yaml";
+function indexingHadFailures(result) {
+  return result.errors.length > 0;
+}
+function legacySourceConfigHint(dest) {
+  const hasLegacy = existsSync(path.join(dest, LEGACY_SOURCE_CONFIG_FILENAME));
+  const hasManifest = existsSync(path.join(dest, SKAILE_MANIFEST_FILENAME));
+  if (hasLegacy && !hasManifest) {
+    return `This source ships a legacy ${LEGACY_SOURCE_CONFIG_FILENAME} but no ${SKAILE_MANIFEST_FILENAME}; its declared publisher is ignored and assets are published under their first path segment. Add a ${SKAILE_MANIFEST_FILENAME} (\`skaile source manifest init\`) to set the publisher and asset inventory.`;
+  }
+  return void 0;
+}
+function normalizeSourceUrl(input) {
+  const s = input.trim();
+  if (/^(?:https?|git|ssh|file):\/\//.test(s) || /^git@/.test(s)) return s;
+  const repo = s.replace(/\.git$/, "");
+  if (/^[\w.-]+\/[\w.-]+$/.test(repo)) return `git@github.com:${repo}.git`;
+  if (/^[\w.-]+$/.test(repo)) return `git@github.com:skaile-ai/${repo}.git`;
+  return s;
+}
+function sourceMatchesKey(entry, key) {
+  if (entry.url === key) return true;
+  if (sourceCacheKey(entry.url) === key || sourceShortName(entry.url) === key) return true;
+  return entry.url === normalizeSourceUrl(key);
+}
+function findCacheKeyCollision(sources, url) {
+  const key = sourceCacheKey(url);
+  return sources.find((s) => s.url !== url && sourceCacheKey(s.url) === key);
+}
+function requireProjectYamlPath() {
+  const root = findWorkspaceRoot(process.cwd());
+  if (!root) {
+    logErr(
+      "No skaile.yaml found in the current directory or any parent. Run `skaile init` first."
+    );
+    process.exit(1);
+  }
+  return path.join(root, workspaceConfigFilename());
+}
+function readProjectSources(yamlPath) {
+  if (!existsSync(yamlPath)) return [];
+  try {
+    return WorkspaceYamlEditor.load(yamlPath).getSources();
+  } catch (err) {
+    logErr(`Could not read ${yamlPath}: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+function ensureClone(entry, opts = {}) {
+  const dest = sourceClonePath(sourceCacheKey(entry.url));
+  let backup;
+  if (existsSync(dest)) {
+    if (!opts.force) return false;
+    backup = `${dest}.bak`;
+    rmSync(backup, { recursive: true, force: true });
+    renameSync(dest, backup);
+  }
+  mkdirSync(path.dirname(dest), { recursive: true });
+  const args = ["clone", entry.url, dest];
+  if (entry.pin) args.splice(1, 0, "--branch", entry.pin);
+  const clone = spawnSync("git", args, { stdio: "inherit" });
+  if (clone.status !== 0) {
+    if (backup) {
+      rmSync(dest, { recursive: true, force: true });
+      renameSync(backup, dest);
+    }
+    logErr(`git clone failed for ${entry.url}`);
+    process.exit(1);
+  }
+  if (backup) rmSync(backup, { recursive: true, force: true });
+  return true;
+}
+async function refreshManifestCache(entry, includeDev = false) {
+  const { manager, library, close } = await openLibraryManager();
+  try {
+    const name = sourceShortName(entry.url);
+    const dest = sourceClonePath(sourceCacheKey(entry.url));
+    const existing = (await manager.listLibraries()).find((l) => l.name === name);
+    const lib = existing ?? await manager.addLibrary({
+      name,
+      path: dest,
+      backend: "git",
+      backendConfig: { url: entry.url, branch: entry.pin ?? "main", authHint: "ssh" },
+      ownership: "reader"
+    });
+    const overlayFile = path.join(getStoreManifestsDir(), `${storeManifestSlug(entry.url)}.yaml`);
+    const catalog = new LocalCatalogSource(library, lib.id, dest, createFullRegistry(), {
+      sidecarManifestFile: existsSync(overlayFile) ? overlayFile : void 0
+    });
+    const result = await catalog.sync({ includeDev });
+    await library.syncSource(lib.id);
+    return result;
+  } finally {
+    close();
+  }
+}
+async function autoSyncForSearch(projectDir) {
+  const root = findWorkspaceRoot(projectDir);
+  if (!root) return false;
+  if (readProjectSources(path.join(root, workspaceConfigFilename())).length === 0) return false;
+  logInfo("sources not synced \u2014 syncing now\u2026");
+  const { synced } = await syncProjectSources(projectDir);
+  return synced > 0;
+}
+async function syncProjectSources(projectDir, opts = {}) {
+  const root = findWorkspaceRoot(projectDir) ?? projectDir;
+  const sources = readProjectSources(path.join(root, workspaceConfigFilename()));
+  let synced = 0;
+  let failed = 0;
+  for (const entry of sources) {
+    const slug = sourceShortName(entry.url);
+    const dest = sourceClonePath(sourceCacheKey(entry.url));
+    try {
+      if (!existsSync(dest)) {
+        mkdirSync(path.dirname(dest), { recursive: true });
+        const args = ["clone", entry.url, dest];
+        if (entry.pin) args.splice(1, 0, "--branch", entry.pin);
+        const clone = spawnSync("git", args, { stdio: "ignore" });
+        if (clone.status !== 0) {
+          logWarn(`${slug}: git clone failed, skipping.`);
+          failed++;
+          continue;
+        }
+      } else {
+        const pull = spawnSync("git", ["pull", "--ff-only"], { cwd: dest, stdio: "ignore" });
+        if (pull.status !== 0) {
+          logWarn(`${slug}: git pull failed, skipping manifest refresh.`);
+          failed++;
+          continue;
+        }
+      }
+      const result = await refreshManifestCache(entry, opts.dev);
+      for (const err of result.errors) logWarn(`${slug}: ${err}`);
+      for (const advisory of result.advisories) logInfo(`${slug}: ${advisory}`);
+      synced++;
+    } catch (err) {
+      logWarn(`${slug}: sync failed \u2014 ${err instanceof Error ? err.message : String(err)}`);
+      failed++;
+    }
+  }
+  return { total: sources.length, synced, failed };
+}
+async function dropManifestCache(url, purgeClone) {
+  const name = sourceShortName(url);
+  const { manager, close } = await openLibraryManager();
+  try {
+    const existing = (await manager.listLibraries()).find((l) => l.name === name);
+    if (existing) {
+      await manager.removeLibrary(name, { purge: false });
+    }
+  } finally {
+    close();
+  }
+  if (purgeClone) {
+    const dest = sourceClonePath(sourceCacheKey(url));
+    if (existsSync(dest)) rmSync(dest, { recursive: true, force: true });
+  }
+}
+function makeSourceCommand() {
+  const cmd = new Command("source").description(
+    "Manage github sources for the current project (recorded in skaile.yaml)"
+  );
+  cmd.command("add <source>").description(
+    "Clone a github repo and register it in this project's skaile.yaml. <source> may be a full git URL, an owner/repo shorthand, or a bare name (\u2192 git@github.com:skaile-ai/<name>.git)."
+  ).option("--name <slug>", "[deprecated] no-op \u2014 the source entry stores only the URL").option("--pin <ref>", "Pin a branch, tag, or 40-char SHA").option("--branch <branch>", "[deprecated] alias for --pin").option("--force", "Remove an existing clone and re-clone", false).option("--dev", "Also index dev-only assets under the source's dev_paths", false).action(
+    async (source, opts) => {
+      const url = normalizeSourceUrl(source);
+      const yamlPath = requireProjectYamlPath();
+      const collision = findCacheKeyCollision(readProjectSources(yamlPath), url);
+      if (collision) {
+        logErr(
+          `"${url}" maps to the same cache key (${sourceCacheKey(url)}) as already-registered "${collision.url}". Remove that source first (skaile source remove) or re-use its exact URL to update it.`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.name) {
+        logWarn(
+          "the --name flag is deprecated; the source entry now stores only the URL (the cache slug is derived from it)."
+        );
+      }
+      const pin = opts.pin ?? opts.branch;
+      const slug = sourceShortName(url);
+      const entry = { url };
+      if (pin) entry.pin = pin;
+      const dest = sourceClonePath(sourceCacheKey(url));
+      const preexisting = existsSync(dest);
+      const cloned = ensureClone(entry, { force: opts.force });
+      if (!cloned) {
+        logOk(`Reusing cached clone at ${dest}`);
+      } else if (preexisting) {
+        logOk(`Re-cloned ${url} \u2192 ${dest}`);
+      } else {
+        logOk(`Cloned ${url} \u2192 ${dest}`);
+      }
+      const editor = WorkspaceYamlEditor.load(yamlPath);
+      editor.setSource(entry);
+      editor.save();
+      const result = await refreshManifestCache(entry, opts.dev);
+      const failed = indexingHadFailures(result);
+      const indexedMsg = `Indexed ${result.assetsUpdated} of ${result.assetsFound} asset(s) from "${slug}".`;
+      if (failed) {
+        logWarn(indexedMsg);
+      } else {
+        logOk(indexedMsg);
+      }
+      for (const err of result.errors) logWarn(err);
+      for (const advisory of result.advisories) logInfo(advisory);
+      const legacyHint = legacySourceConfigHint(dest);
+      if (legacyHint) logWarn(legacyHint);
+      const where = path.relative(process.cwd(), yamlPath);
+      if (failed) {
+        logWarn(
+          `Source "${slug}" registered in ${where}, but ${result.errors.length} asset(s) failed to index (see above). Fix the cause, then re-run \`skaile source sync ${slug}\`.`
+        );
+        process.exitCode = 1;
+      } else {
+        logOk(`Source "${slug}" registered in ${where}.`);
+      }
+    }
+  );
+  cmd.command("list").description("List sources registered in this project's skaile.yaml").option("--json", "Output as JSON").action(async (opts) => {
+    const yamlPath = requireProjectYamlPath();
+    const sources = readProjectSources(yamlPath);
+    if (opts.json) return console.log(JSON.stringify(sources, null, 2));
+    if (sources.length === 0) {
+      logInfo("No sources in skaile.yaml. Run `skaile source add <git-url>` to register one.");
+      return;
+    }
+    console.log();
+    console.log(S.heading("  Sources"));
+    for (const s of sources) {
+      const slug = sourceShortName(s.url);
+      const cached = existsSync(sourceClonePath(sourceCacheKey(s.url))) ? "" : S.warn(" (not cached)");
+      console.log(`  ${S.cmd(slug.padEnd(24))}  ${S.dim(s.url)}${cached}`);
+    }
+    console.log(`
+  ${S.dim(`${sources.length} source(s)`)}
+`);
+  });
+  cmd.command("show <name-or-url>").description("Show details for a source (matched by URL or derived slug)").action(async (key) => {
+    const yamlPath = requireProjectYamlPath();
+    const entry = readProjectSources(yamlPath).find((s) => sourceMatchesKey(s, key));
+    if (!entry) {
+      logErr(`No source matching "${key}" in ${yamlPath}.`);
+      process.exit(1);
+    }
+    const slug = sourceShortName(entry.url);
+    const clonePath = sourceClonePath(sourceCacheKey(entry.url));
+    console.log(
+      JSON.stringify(
+        {
+          ...entry,
+          slug,
+          clonePath,
+          cached: existsSync(clonePath)
+        },
+        null,
+        2
+      )
+    );
+  });
+  cmd.command("remove <name-or-url>").description("Remove a source from this project's skaile.yaml (matched by URL or slug)").option("--purge", "Also delete the cached clone from ~/.skaile/cache/sources/", false).action(async (key, opts) => {
+    const yamlPath = requireProjectYamlPath();
+    const editor = WorkspaceYamlEditor.load(yamlPath);
+    const match = editor.getSources().find((s) => sourceMatchesKey(s, key));
+    if (!match) {
+      logErr(`No source matching "${key}" in ${yamlPath}.`);
+      process.exit(1);
+    }
+    const slug = sourceShortName(match.url);
+    editor.removeSource(match.url);
+    editor.save();
+    await dropManifestCache(match.url, opts.purge);
+    logOk(
+      opts.purge ? `Removed source "${slug}" and purged its clone.` : `Removed source "${slug}" from skaile.yaml (clone left in ~/.skaile/cache/sources/ \u2014 pass --purge to remove it, or run \`skaile cache clean\`).`
+    );
+  });
+  cmd.command("sync [name]").description("Pull upstream changes and refresh the manifest cache").option("--dev", "Also index dev-only assets under each source's dev_paths", false).option("--all", "Sync every source without prompting", false).action(async (key, opts) => {
+    const yamlPath = requireProjectYamlPath();
+    const sources = readProjectSources(yamlPath);
+    if (sources.length === 0) {
+      logInfo("No sources in skaile.yaml.");
+      return;
+    }
+    let targets;
+    if (key) {
+      targets = sources.filter((s) => sourceMatchesKey(s, key));
+      if (targets.length === 0) {
+        logInfo(`No source matching "${key}".`);
+        return;
+      }
+    } else if (opts.all || sources.length === 1 || !process.stdin.isTTY) {
+      targets = sources;
+    } else {
+      const selected = await p.multiselect({
+        message: "Select sources to sync",
+        options: sources.map((s) => ({
+          value: s.url,
+          label: sourceShortName(s.url),
+          hint: s.url
+        })),
+        required: true
+      });
+      if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        return;
+      }
+      const picked = new Set(selected);
+      targets = sources.filter((s) => picked.has(s.url));
+    }
+    for (const entry of targets) {
+      const slug = sourceShortName(entry.url);
+      const dest = sourceClonePath(sourceCacheKey(entry.url));
+      if (!existsSync(dest)) {
+        ensureClone(entry);
+        logOk(`${slug}: cloned to ${dest}.`);
+      } else {
+        const pull = spawnSync("git", ["pull", "--ff-only"], { cwd: dest, stdio: "inherit" });
+        if (pull.status !== 0) {
+          logWarn(`${slug}: git pull failed, skipping manifest refresh.`);
+          continue;
+        }
+      }
+      const result = await refreshManifestCache(entry, opts.dev);
+      const failed = indexingHadFailures(result);
+      const indexedMsg = `${slug}: indexed ${result.assetsUpdated} of ${result.assetsFound} asset(s).`;
+      if (failed) {
+        logWarn(indexedMsg);
+        process.exitCode = 1;
+      } else {
+        logOk(indexedMsg);
+      }
+      for (const err of result.errors) logWarn(`${slug}: ${err}`);
+      for (const advisory of result.advisories) logInfo(`${slug}: ${advisory}`);
+      const legacyHint = legacySourceConfigHint(dest);
+      if (legacyHint) logWarn(`${slug}: ${legacyHint}`);
+    }
+  });
+  cmd.command("patch <ref>").description("Extract an asset for editing against the source").action((_ref) => {
+    logErr(
+      "`skaile source patch` is scaffolded but not yet wired. The patch flow lands in a follow-up PR."
+    );
+    process.exit(2);
+  });
+  cmd.command("propose <ref>").description("Open a PR with the patch against the source upstream").action((_ref) => {
+    logErr(
+      "`skaile source propose` is scaffolded but not yet wired. The propose flow lands in a follow-up PR."
+    );
+    process.exit(2);
+  });
+  addSourceManifestCommands(cmd);
+  return cmd;
+}
+
+export { autoSyncForSearch, ensureClone, findCacheKeyCollision, indexingHadFailures, legacySourceConfigHint, makeSourceCommand, normalizeSourceUrl, readProjectSources, resolveSourceArg, sourceClonePath, sourceMatchesKey, syncProjectSources };
+//# sourceMappingURL=chunk-WYGXYGJH.js.map
+//# sourceMappingURL=chunk-WYGXYGJH.js.map