forgemap 0.4.1-dev.68-66824fb → 0.4.1-dev.70-e2b787f

package/dist/bin/forgemap.mjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
-import { readdir, readFile, mkdir, writeFile, stat, rm, rmdir, rename, access } from "node:fs/promises";
+import { readdir, readFile, mkdir, writeFile, stat, rmdir, rm, rename, access } from "node:fs/promises";
 import { colors, formatTree } from "consola/utils";
 import { isAbsolute, resolve, dirname, join } from "pathe";
 import { homedir } from "node:os";
 import { existsSync } from "node:fs";
 import { loadConfig } from "c12";
-import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
 import Fuse from "fuse.js";
 const cdCommand = defineCommand({
   meta: {
@@ -110,6 +110,163 @@ async function loadForgeMapConfig(options = {}) {
     cwd
   };
 }
+async function listDirs$1(path) {
+  try {
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+async function scanRepos(options) {
+  const { config, configDir } = options;
+  const root = resolveRoot(config.root, configDir);
+  const repos = [];
+  for (const [forgeName, forge] of Object.entries(config.forges)) {
+    const forgeRoot = join(root, forge.dir);
+    const owners = await listDirs$1(forgeRoot);
+    for (const owner of owners) {
+      const ownerPath = join(forgeRoot, owner);
+      const repoNames = await listDirs$1(ownerPath);
+      for (const repo of repoNames) {
+        repos.push({
+          forgeName,
+          forge,
+          owner,
+          repo,
+          localPath: join(ownerPath, repo),
+          slug: `${owner}/${repo}`
+        });
+      }
+    }
+  }
+  return repos;
+}
+const DEFAULT_TTL_MS = 6e4;
+function ttl() {
+  const env = process.env.FORGEMAP_CACHE_TTL_MS;
+  if (!env) return DEFAULT_TTL_MS;
+  const parsed = Number.parseInt(env, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_TTL_MS;
+}
+function cacheDir() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  return xdg ? join(xdg, "forgemap") : join(homedir(), ".cache", "forgemap");
+}
+function cachePath(root) {
+  const hash = createHash("sha1").update(root).digest("hex").slice(0, 16);
+  return join(cacheDir(), `scan-${hash}.json`);
+}
+async function safeStat(path) {
+  try {
+    const s = await stat(path);
+    return Math.trunc(s.mtimeMs);
+  } catch {
+    return 0;
+  }
+}
+async function safeListDirs(path) {
+  try {
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function computeFingerprint(config, configDir) {
+  const root = resolveRoot(config.root, configDir);
+  const perForge = await Promise.all(
+    Object.values(config.forges).map(async (forge) => {
+      const forgeRoot = join(root, forge.dir);
+      const [forgeMtime, owners] = await Promise.all([
+        safeStat(forgeRoot),
+        safeListDirs(forgeRoot)
+      ]);
+      const ownerEntries = await Promise.all(
+        owners.map(async (owner) => {
+          const ownerPath = join(forgeRoot, owner);
+          return [ownerPath, await safeStat(ownerPath)];
+        })
+      );
+      return [[forgeRoot, forgeMtime], ...ownerEntries];
+    })
+  );
+  const entries = [[root, await safeStat(root)]];
+  for (const group of perForge) entries.push(...group);
+  entries.sort((a, b) => a[0].localeCompare(b[0]));
+  return createHash("sha1").update(entries.map(([p, m]) => `${p}:${m}`).join("\n")).digest("hex");
+}
+async function readCacheFile(file) {
+  try {
+    const raw = await readFile(file, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeCacheFile(file, payload) {
+  await mkdir(cacheDir(), { recursive: true });
+  await writeFile(file, JSON.stringify(payload), "utf8");
+}
+async function scanReposCached(options) {
+  const { config, configDir, useCache = true, trustTtl = true } = options;
+  const root = resolveRoot(config.root, configDir);
+  const file = cachePath(root);
+  if (useCache) {
+    const cached = await readCacheFile(file);
+    if (cached) {
+      const age = Date.now() - cached.writtenAt;
+      if (trustTtl && age < ttl()) {
+        return cached.repos;
+      }
+      const fingerprint2 = await computeFingerprint(config, configDir);
+      if (cached.fingerprint === fingerprint2) {
+        await writeCacheFile(file, { ...cached, writtenAt: Date.now() });
+        return cached.repos;
+      }
+    }
+  }
+  const repos = await scanRepos({ config, configDir });
+  const fingerprint = await computeFingerprint(config, configDir);
+  await writeCacheFile(file, {
+    fingerprint,
+    writtenAt: Date.now(),
+    repos
+  });
+  return repos;
+}
+async function appendCachedRepo(options, repo) {
+  const { config, configDir } = options;
+  const root = resolveRoot(config.root, configDir);
+  const file = cachePath(root);
+  const cached = await readCacheFile(file);
+  if (!cached) {
+    return;
+  }
+  if (cached.repos.some((r) => r.localPath === repo.localPath)) {
+    return;
+  }
+  await writeCacheFile(file, {
+    fingerprint: await computeFingerprint(config, configDir),
+    writtenAt: Date.now(),
+    repos: [...cached.repos, repo]
+  });
+}
+async function removeCachedRepo(options, localPath) {
+  const { config, configDir } = options;
+  const root = resolveRoot(config.root, configDir);
+  const file = cachePath(root);
+  const cached = await readCacheFile(file);
+  if (!cached) return;
+  const next = cached.repos.filter((r) => r.localPath !== localPath);
+  if (next.length === cached.repos.length) return;
+  await writeCacheFile(file, {
+    fingerprint: await computeFingerprint(config, configDir),
+    writtenAt: Date.now(),
+    repos: next
+  });
+}
 function execInherit(command, args) {
   return new Promise((resolvePromise, rejectPromise) => {
     const child = spawn(command, args, { stdio: "inherit" });
@@ -390,162 +547,61 @@ function getForgeAdapter(type) {
     }
   }
 }
-async function listDirs$1(path) {
-  try {
-    const entries = await readdir(path, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
-  } catch (error) {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  }
-}
-async function scanRepos(options) {
-  const { config, configDir } = options;
-  const root = resolveRoot(config.root, configDir);
-  const repos = [];
-  for (const [forgeName, forge] of Object.entries(config.forges)) {
-    const forgeRoot = join(root, forge.dir);
-    const owners = await listDirs$1(forgeRoot);
-    for (const owner of owners) {
-      const ownerPath = join(forgeRoot, owner);
-      const repoNames = await listDirs$1(ownerPath);
-      for (const repo of repoNames) {
-        repos.push({
-          forgeName,
-          forge,
-          owner,
-          repo,
-          localPath: join(ownerPath, repo),
-          slug: `${owner}/${repo}`
-        });
-      }
-    }
-  }
-  return repos;
-}
-const DEFAULT_TTL_MS = 6e4;
-function ttl() {
-  const env = process.env.FORGEMAP_CACHE_TTL_MS;
-  if (!env) return DEFAULT_TTL_MS;
-  const parsed = Number.parseInt(env, 10);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_TTL_MS;
-}
-function cacheDir() {
-  const xdg = process.env.XDG_CACHE_HOME;
-  return xdg ? join(xdg, "forgemap") : join(homedir(), ".cache", "forgemap");
-}
-function cachePath(root) {
-  const hash = createHash("sha1").update(root).digest("hex").slice(0, 16);
-  return join(cacheDir(), `scan-${hash}.json`);
+const SHORT_RE = /^([\w.-]+)\/([\w.-]+)$/;
+const NAMED_RE = /^([\w.-]+):([\w.-]+)\/([\w.-]+)$/;
+const SSH_RE = /^git@([\w.-]+):([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
+function stripGitSuffix(repo) {
+  return repo.endsWith(".git") ? repo.slice(0, -4) : repo;
 }
-async function safeStat(path) {
-  try {
-    const s = await stat(path);
-    return Math.trunc(s.mtimeMs);
-  } catch {
-    return 0;
-  }
+function looksLikeSlug(input) {
+  return input.trim().includes("/");
 }
-async function safeListDirs(path) {
-  try {
-    const entries = await readdir(path, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
-  } catch {
-    return [];
+function parseSlug(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("Slug is empty");
   }
-}
-async function computeFingerprint(config, configDir) {
-  const root = resolveRoot(config.root, configDir);
-  const perForge = await Promise.all(
-    Object.values(config.forges).map(async (forge) => {
-      const forgeRoot = join(root, forge.dir);
-      const [forgeMtime, owners] = await Promise.all([
-        safeStat(forgeRoot),
-        safeListDirs(forgeRoot)
-      ]);
-      const ownerEntries = await Promise.all(
-        owners.map(async (owner) => {
-          const ownerPath = join(forgeRoot, owner);
-          return [ownerPath, await safeStat(ownerPath)];
-        })
-      );
-      return [[forgeRoot, forgeMtime], ...ownerEntries];
-    })
-  );
-  const entries = [[root, await safeStat(root)]];
-  for (const group of perForge) entries.push(...group);
-  entries.sort((a, b) => a[0].localeCompare(b[0]));
-  return createHash("sha1").update(entries.map(([p, m]) => `${p}:${m}`).join("\n")).digest("hex");
-}
-async function readCacheFile(file) {
-  try {
-    const raw = await readFile(file, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
+  const ssh = SSH_RE.exec(trimmed);
+  if (ssh) {
+    return {
+      host: ssh[1],
+      owner: ssh[2],
+      repo: stripGitSuffix(ssh[3])
+    };
   }
-}
-async function writeCacheFile(file, payload) {
-  await mkdir(cacheDir(), { recursive: true });
-  await writeFile(file, JSON.stringify(payload), "utf8");
-}
-async function scanReposCached(options) {
-  const { config, configDir, useCache = true, trustTtl = true } = options;
-  const root = resolveRoot(config.root, configDir);
-  const file = cachePath(root);
-  if (useCache) {
-    const cached = await readCacheFile(file);
-    if (cached) {
-      const age = Date.now() - cached.writtenAt;
-      if (trustTtl && age < ttl()) {
-        return cached.repos;
-      }
-      const fingerprint2 = await computeFingerprint(config, configDir);
-      if (cached.fingerprint === fingerprint2) {
-        await writeCacheFile(file, { ...cached, writtenAt: Date.now() });
-        return cached.repos;
-      }
+  if (/^https?:\/\//.test(trimmed)) {
+    let url;
+    try {
+      url = new URL(trimmed);
+    } catch {
+      throw new Error(`Invalid URL: ${trimmed}`);
+    }
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (segments.length < 2) {
+      throw new Error(`URL must contain owner and repo: ${trimmed}`);
     }
+    return {
+      host: url.host,
+      owner: segments[0],
+      repo: stripGitSuffix(segments[1])
+    };
   }
-  const repos = await scanRepos({ config, configDir });
-  const fingerprint = await computeFingerprint(config, configDir);
-  await writeCacheFile(file, {
-    fingerprint,
-    writtenAt: Date.now(),
-    repos
-  });
-  return repos;
-}
-async function appendCachedRepo(options, repo) {
-  const { config, configDir } = options;
-  const root = resolveRoot(config.root, configDir);
-  const file = cachePath(root);
-  const cached = await readCacheFile(file);
-  if (!cached) {
-    return;
+  const named = NAMED_RE.exec(trimmed);
+  if (named) {
+    return {
+      forgeName: named[1],
+      owner: named[2],
+      repo: stripGitSuffix(named[3])
+    };
   }
-  if (cached.repos.some((r) => r.localPath === repo.localPath)) {
-    return;
+  const short = SHORT_RE.exec(trimmed);
+  if (short) {
+    return {
+      owner: short[1],
+      repo: stripGitSuffix(short[2])
+    };
   }
-  await writeCacheFile(file, {
-    fingerprint: await computeFingerprint(config, configDir),
-    writtenAt: Date.now(),
-    repos: [...cached.repos, repo]
-  });
-}
-async function removeCachedRepo(options, localPath) {
-  const { config, configDir } = options;
-  const root = resolveRoot(config.root, configDir);
-  const file = cachePath(root);
-  const cached = await readCacheFile(file);
-  if (!cached) return;
-  const next = cached.repos.filter((r) => r.localPath !== localPath);
-  if (next.length === cached.repos.length) return;
-  await writeCacheFile(file, {
-    fingerprint: await computeFingerprint(config, configDir),
-    writtenAt: Date.now(),
-    repos: next
-  });
+  throw new Error(`Unrecognized slug format: ${input}`);
 }
 async function gitIn(cwd, args) {
   return execCapture("git", args, { cwd });
@@ -650,87 +706,57 @@ async function getLastCommitUnix(localPath) {
   return Number.isFinite(ts) ? ts : null;
 }
 async function hasUnpushedCommits(localPath) {
-  const result = await gitIn(localPath, [
-    "log",
-    "--branches",
-    "--not",
-    "--remotes",
-    "--format=%H",
-    "-1"
-  ]);
-  if (result.code !== 0) return true;
-  return result.stdout.trim().length > 0;
-}
-async function countStashes(localPath) {
-  const result = await gitIn(localPath, ["stash", "list", "--format=%gd"]);
-  if (result.code !== 0) return 0;
-  return result.stdout.split("\n").filter((line) => line.trim().length > 0).length;
-}
-const SHORT_RE = /^([\w.-]+)\/([\w.-]+)$/;
-const NAMED_RE = /^([\w.-]+):([\w.-]+)\/([\w.-]+)$/;
-const SSH_RE = /^git@([\w.-]+):([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
-function stripGitSuffix(repo) {
-  return repo.endsWith(".git") ? repo.slice(0, -4) : repo;
-}
-function looksLikeSlug(input) {
-  return input.trim().includes("/");
-}
-function parseSlug(input) {
-  const trimmed = input.trim();
-  if (!trimmed) {
-    throw new Error("Slug is empty");
-  }
-  const ssh = SSH_RE.exec(trimmed);
-  if (ssh) {
-    return {
-      host: ssh[1],
-      owner: ssh[2],
-      repo: stripGitSuffix(ssh[3])
-    };
-  }
-  if (/^https?:\/\//.test(trimmed)) {
-    let url;
-    try {
-      url = new URL(trimmed);
-    } catch {
-      throw new Error(`Invalid URL: ${trimmed}`);
-    }
-    const segments = url.pathname.split("/").filter(Boolean);
-    if (segments.length < 2) {
-      throw new Error(`URL must contain owner and repo: ${trimmed}`);
+  const result = await gitIn(localPath, [
+    "log",
+    "--branches",
+    "--not",
+    "--remotes",
+    "--format=%H",
+    "-1"
+  ]);
+  if (result.code !== 0) return true;
+  return result.stdout.trim().length > 0;
+}
+async function getUnpushedBranches(localPath) {
+  const listed = await gitIn(localPath, [
+    "for-each-ref",
+    "--format=%(refname:short)",
+    "refs/heads"
+  ]);
+  if (listed.code !== 0) return [];
+  const branches = listed.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+  const unpushed = [];
+  for (const branch of branches) {
+    const result = await gitIn(localPath, [
+      "log",
+      branch,
+      "--not",
+      "--remotes",
+      "--format=%H",
+      "-1"
+    ]);
+    if (result.code === 0 && result.stdout.trim().length > 0) {
+      unpushed.push(branch);
     }
-    return {
-      host: url.host,
-      owner: segments[0],
-      repo: stripGitSuffix(segments[1])
-    };
-  }
-  const named = NAMED_RE.exec(trimmed);
-  if (named) {
-    return {
-      forgeName: named[1],
-      owner: named[2],
-      repo: stripGitSuffix(named[3])
-    };
-  }
-  const short = SHORT_RE.exec(trimmed);
-  if (short) {
-    return {
-      owner: short[1],
-      repo: stripGitSuffix(short[2])
-    };
   }
-  throw new Error(`Unrecognized slug format: ${input}`);
+  return unpushed;
+}
+async function countStashes(localPath) {
+  const result = await gitIn(localPath, ["stash", "list", "--format=%gd"]);
+  if (result.code !== 0) return 0;
+  return result.stdout.split("\n").filter((line) => line.trim().length > 0).length;
 }
-const DAY_SECONDS = 86400;
-const LOCAL_CONCURRENCY$1 = 16;
 const REMOTE_CONCURRENCY$1 = 10;
-async function evaluate(repo, cutoffUnix) {
+async function evaluateRepo(repo, options = {}) {
   if (!await isGitRepo(repo.localPath)) return null;
   const origin = await getOriginUrl(repo.localPath);
   if (!origin) return null;
   const lastCommitUnix = await getLastCommitUnix(repo.localPath);
-  if (lastCommitUnix === null || lastCommitUnix > cutoffUnix) return null;
+  if (options.cutoffUnix !== void 0) {
+    if (lastCommitUnix === null || lastCommitUnix > options.cutoffUnix) {
+      return null;
+    }
+  }
   const status = await getRepoStatus(repo.localPath);
   const dirty = status.dirty;
   const stashes = status.stashes;
@@ -754,6 +780,30 @@ async function evaluate(repo, cutoffUnix) {
     stashes
   };
 }
+const UNCOMMITTED = "uncommitted changes";
+const UNPUSHED = "unpushed commits";
+const STASHED = "stashed work";
+function stashedReason(stashes) {
+  return `${STASHED} (${stashes} stash${stashes === 1 ? "" : "es"})`;
+}
+function localGateOverride(reason) {
+  if (reason === UNCOMMITTED) return "--include-dirty";
+  if (reason === UNPUSHED) return "--include-unpushed";
+  if (reason.startsWith(STASHED)) return "--include-stashed";
+  return void 0;
+}
+function localBlocker(evaluation, overrides) {
+  if (evaluation.dirty && !overrides.includeDirty) return UNCOMMITTED;
+  if (evaluation.unpushed && !overrides.includeUnpushed) return UNPUSHED;
+  if (evaluation.stashes > 0 && !overrides.includeStashed) {
+    return stashedReason(evaluation.stashes);
+  }
+  return null;
+}
+function remoteBlocker(state) {
+  if (state === "exists" || state === "moved") return null;
+  return state === "gone" ? "remote no longer exists" : "remote unreachable";
+}
 async function classifyRemotes(candidates) {
   const byType = /* @__PURE__ */ new Map();
   for (const c of candidates) {
@@ -812,6 +862,48 @@ async function classifyRemotes(candidates) {
   );
   return results;
 }
+async function safeReaddir(path) {
+  try {
+    return await readdir(path);
+  } catch {
+    return null;
+  }
+}
+async function findEmptyDirs(root, config) {
+  const empties = [];
+  for (const forge of Object.values(config.forges)) {
+    const serverPath = join(root, forge.dir);
+    const owners = await safeReaddir(serverPath);
+    if (owners === null) continue;
+    let emptyCount = 0;
+    for (const owner of owners) {
+      const ownerPath = join(serverPath, owner);
+      const inner = await safeReaddir(ownerPath);
+      if (inner !== null && inner.length === 0) {
+        empties.push(ownerPath);
+        emptyCount++;
+      }
+    }
+    if (owners.length === 0 || emptyCount === owners.length) {
+      empties.push(serverPath);
+    }
+  }
+  return empties;
+}
+async function pruneEmptyDirs(root, config) {
+  const empties = await findEmptyDirs(root, config);
+  let removed = 0;
+  for (const dir of empties) {
+    try {
+      await rmdir(dir);
+      removed++;
+    } catch {
+    }
+  }
+  return removed;
+}
+const DAY_SECONDS = 86400;
+const LOCAL_CONCURRENCY$1 = 16;
 function ageDays(lastCommitUnix) {
   return Math.floor(
     Date.now() / 1e3 / DAY_SECONDS - lastCommitUnix / DAY_SECONDS
@@ -886,35 +978,21 @@ const cleanupCommand = defineCommand({
     const stale = (await mapLimit(
       repos,
       LOCAL_CONCURRENCY$1,
-      (repo) => evaluate(repo, cutoffUnix)
+      (repo) => evaluateRepo(repo, { cutoffUnix })
     )).filter((c) => c !== null);
     const includeDirty = Boolean(args["include-dirty"]);
     const includeUnpushed = Boolean(args["include-unpushed"]);
     const includeStashed = Boolean(args["include-stashed"]);
-    const localOk = (c) => (!c.dirty || includeDirty) && (!c.unpushed || includeUnpushed) && (c.stashes === 0 || includeStashed);
-    const remoteStates = await classifyRemotes(stale.filter(localOk));
+    const overrides = { includeDirty, includeUnpushed, includeStashed };
+    const remoteStates = await classifyRemotes(
+      stale.filter((c) => localBlocker(c, overrides) === null)
+    );
     const candidates = [];
     const kept = [];
     for (const c of stale) {
-      if (c.dirty && !includeDirty) {
-        kept.push({ repo: c, reason: "uncommitted changes" });
-      } else if (c.unpushed && !includeUnpushed) {
-        kept.push({ repo: c, reason: "unpushed commits" });
-      } else if (c.stashes > 0 && !includeStashed) {
-        kept.push({
-          repo: c,
-          reason: `stashed work (${c.stashes} stash${c.stashes === 1 ? "" : "es"})`
-        });
-      } else {
-        const state = remoteStates.get(c.repo.localPath)?.state;
-        if (state === "exists" || state === "moved") candidates.push(c);
-        else {
-          kept.push({
-            repo: c,
-            reason: state === "gone" ? "remote no longer exists" : "remote unreachable"
-          });
-        }
-      }
+      const reason = localBlocker(c, overrides) ?? remoteBlocker(remoteStates.get(c.repo.localPath)?.state);
+      if (reason === null) candidates.push(c);
+      else kept.push({ repo: c, reason });
     }
     candidates.sort((a, b) => a.lastCommitUnix - b.lastCommitUnix);
     kept.sort((a, b) => a.repo.lastCommitUnix - b.repo.lastCommitUnix);
@@ -1008,46 +1086,6 @@ const cleanupCommand = defineCommand({
     }
   }
 });
-async function safeReaddir(path) {
-  try {
-    return await readdir(path);
-  } catch {
-    return null;
-  }
-}
-async function findEmptyDirs(root, config) {
-  const empties = [];
-  for (const forge of Object.values(config.forges)) {
-    const serverPath = join(root, forge.dir);
-    const owners = await safeReaddir(serverPath);
-    if (owners === null) continue;
-    let emptyCount = 0;
-    for (const owner of owners) {
-      const ownerPath = join(serverPath, owner);
-      const inner = await safeReaddir(ownerPath);
-      if (inner !== null && inner.length === 0) {
-        empties.push(ownerPath);
-        emptyCount++;
-      }
-    }
-    if (owners.length === 0 || emptyCount === owners.length) {
-      empties.push(serverPath);
-    }
-  }
-  return empties;
-}
-async function pruneEmptyDirs(root, config) {
-  const empties = await findEmptyDirs(root, config);
-  let removed = 0;
-  for (const dir of empties) {
-    try {
-      await rmdir(dir);
-      removed++;
-    } catch {
-    }
-  }
-  return removed;
-}
 function findForgeByHost(forges, host) {
   for (const [name, forge] of Object.entries(forges)) {
     if (forge.host.toLowerCase() === host.toLowerCase()) {
@@ -1233,6 +1271,7 @@ const SUBCOMMANDS = [
   "clone",
   "import",
   "cleanup",
+  "delete",
   "cd",
   "path",
   "open",
@@ -1245,7 +1284,15 @@ const SUBCOMMANDS = [
   "completion",
   "config"
 ];
-const SLUG_COMMANDS = ["clone", "cd", "path", "open", "search", "pick"];
+const SLUG_COMMANDS = [
+  "clone",
+  "cd",
+  "path",
+  "open",
+  "search",
+  "pick",
+  "delete"
+];
 function renderBash() {
   return `# forgemap bash completion — drop into your ~/.bashrc:
 #   eval "$(forgemap completion bash)"
@@ -1501,6 +1548,164 @@ const configCommand = defineCommand({
     show: configShowCommand
   }
 });
+const deleteCommand = defineCommand({
+  meta: {
+    name: "delete",
+    description: "Delete one local repo by slug, behind the same safety gates as cleanup (no staleness requirement)"
+  },
+  args: {
+    slug: {
+      type: "positional",
+      description: "owner/repo, forge:owner/repo, or full URL",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Only report what would happen; never prompt or delete",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip the interactive confirmation (deletes immediately)",
+      default: false
+    },
+    "include-dirty": {
+      type: "boolean",
+      description: "Also delete when there are uncommitted changes (those changes are lost)",
+      default: false
+    },
+    "include-unpushed": {
+      type: "boolean",
+      description: "Also delete when there are unpushed commits (those commits are lost)",
+      default: false
+    },
+    "include-stashed": {
+      type: "boolean",
+      description: "Also delete when there is stashed work (that stash is lost)",
+      default: false
+    },
+    config: {
+      type: "string",
+      description: "Path to forgemap.config.ts (overrides walk-up discovery)"
+    }
+  },
+  async run({ args }) {
+    const loaded = await loadForgeMapConfig({ configFile: args.config });
+    const configDir = loaded.configFile ? dirname(loaded.configFile) : loaded.cwd;
+    let resolved;
+    try {
+      resolved = resolveSlug(parseSlug(args.slug), {
+        config: loaded.config,
+        configDir
+      });
+    } catch (error) {
+      consola.error(error.message);
+      process.exitCode = 1;
+      return;
+    }
+    const repo = {
+      forgeName: resolved.forgeName,
+      forge: resolved.forge,
+      owner: resolved.owner,
+      repo: resolved.repo,
+      localPath: resolved.localPath,
+      slug: `${resolved.owner}/${resolved.repo}`
+    };
+    if (!existsSync(repo.localPath)) {
+      consola.error(
+        `No local repo at ${repo.localPath} — nothing to delete for ${repo.forgeName}:${repo.slug}.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const evaluation = await evaluateRepo(repo);
+    if (!evaluation) {
+      consola.error(
+        `Refusing to delete ${colors.cyan(`${repo.forgeName}:${repo.slug}`)} — ${repo.localPath} is not a git repo with an "origin" remote, so there is no remote copy to fall back on. Remove it by hand if you are sure.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    process.stdout.write(
+      `${colors.bold(`${repo.forgeName}:${repo.slug}`)}  ${colors.dim(repo.localPath)}
+`
+    );
+    const unpushedBranches = evaluation.unpushed ? await getUnpushedBranches(repo.localPath) : [];
+    const losses = [];
+    if (evaluation.dirty) losses.push("uncommitted changes");
+    if (evaluation.unpushed) {
+      losses.push(
+        unpushedBranches.length > 0 ? `unpushed commits on ${unpushedBranches.join(", ")}` : "unpushed commits"
+      );
+    }
+    if (evaluation.stashes > 0) {
+      losses.push(
+        `${evaluation.stashes} stash${evaluation.stashes === 1 ? "" : "es"}`
+      );
+    }
+    if (losses.length > 0) {
+      process.stdout.write(
+        `  ${colors.red("local-only work:")} ${losses.join("; ")}
+`
+      );
+    }
+    process.stdout.write("\n");
+    const remoteStates = await classifyRemotes([evaluation]);
+    const remoteReason = remoteBlocker(remoteStates.get(repo.localPath)?.state);
+    if (remoteReason) {
+      consola.error(
+        `Refusing to delete — ${remoteReason}. This is never overridable: the local copy may be the only one left.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const localReason = localBlocker(evaluation, {
+      includeDirty: Boolean(args["include-dirty"]),
+      includeUnpushed: Boolean(args["include-unpushed"]),
+      includeStashed: Boolean(args["include-stashed"])
+    });
+    if (localReason) {
+      const hint = localGateOverride(localReason);
+      consola.error(
+        `Refusing to delete — ${localReason}${hint ? `. Pass ${hint} to delete anyway (that work is lost)` : ""}.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (args["dry-run"]) {
+      consola.info("Dry run — nothing deleted.");
+      return;
+    }
+    if (losses.length > 0) {
+      consola.warn(
+        `This repo has local-only work that will be permanently lost: ${losses.join("; ")}.`
+      );
+    }
+    let confirmed = args.yes;
+    if (!confirmed) {
+      const answer = await consola.prompt(
+        `Type "yes" to delete ${repo.slug} locally:`,
+        { type: "text", cancel: "null" }
+      );
+      confirmed = typeof answer === "string" && answer.trim() === "yes";
+    }
+    if (!confirmed) {
+      consola.info("Aborted — nothing deleted.");
+      return;
+    }
+    await rm(repo.localPath, { recursive: true, force: true });
+    await removeCachedRepo(
+      { config: loaded.config, configDir },
+      repo.localPath
+    );
+    consola.success(`Deleted ${repo.localPath}`);
+    const root = resolveRoot(loaded.config.root, configDir);
+    const emptied = await pruneEmptyDirs(root, loaded.config);
+    if (emptied > 0) {
+      consola.success(`Removed ${emptied} empty folder(s).`);
+    }
+  }
+});
 async function listDirs(path) {
   try {
     const entries = await readdir(path, { withFileTypes: true });
@@ -2294,6 +2499,44 @@ const pickCommand = defineCommand({
     }
   }
 });
+const FLAG = "--filter";
+const filterArg = {
+  type: "string",
+  description: "Restrict to repos whose owner or forge name matches. Repeatable; a repo passes if it matches any value."
+};
+function collectFilterArgs(rawArgs) {
+  const values = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === "--") break;
+    if (arg === FLAG) {
+      const next = rawArgs[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        values.push(next);
+        i++;
+      }
+      continue;
+    }
+    if (arg.startsWith(`${FLAG}=`)) values.push(arg.slice(FLAG.length + 1));
+  }
+  return values;
+}
+function normalizeFilters(value) {
+  if (value === void 0) return [];
+  const values = Array.isArray(value) ? value : [value];
+  return values.map((v) => v.trim()).filter((v) => v.length > 0);
+}
+function resolveFilters(rawArgs, value) {
+  const fromRawArgs = collectFilterArgs(rawArgs);
+  return normalizeFilters(fromRawArgs.length > 0 ? fromRawArgs : value);
+}
+function filterRepos(repos, filters) {
+  if (filters.length === 0) return repos;
+  const wanted = new Set(filters.map((f) => f.toLowerCase()));
+  return repos.filter(
+    (r) => wanted.has(r.owner.toLowerCase()) || wanted.has(r.forgeName.toLowerCase())
+  );
+}
 function renderTree$1(repos) {
   const byForge = /* @__PURE__ */ new Map();
   for (const r of repos) {
@@ -2334,6 +2577,7 @@ const searchCommand = defineCommand({
       description: "Output format: auto (default), pretty, path, or slug. auto picks pretty in a TTY, path when piped.",
       default: "auto"
     },
+    filter: filterArg,
     limit: {
       type: "string",
       description: "Maximum number of matches to print (default: unlimited)"
@@ -2343,10 +2587,11 @@ const searchCommand = defineCommand({
       description: "Path to forgemap.config.ts (overrides walk-up discovery)"
     }
   },
-  async run({ args }) {
+  async run({ args, rawArgs }) {
     const loaded = await loadForgeMapConfig({ configFile: args.config });
     const configDir = loaded.configFile ? dirname(loaded.configFile) : loaded.cwd;
-    const repos = await scanRepos({ config: loaded.config, configDir });
+    const scanned = await scanRepos({ config: loaded.config, configDir });
+    const repos = filterRepos(scanned, resolveFilters(rawArgs, args.filter));
     const limit = args.limit ? Number.parseInt(args.limit, 10) : void 0;
     const items = matchRepos(repos, args.query, limit);
     const allowed = ["auto", "pretty", "path", "slug"];
@@ -2559,6 +2804,7 @@ const statusCommand = defineCommand({
       type: "string",
       description: "Restrict to a single forge alias"
     },
+    filter: filterArg,
     query: {
       type: "string",
       description: "Fuzzy filter against <owner>/<repo>"
@@ -2573,7 +2819,7 @@ const statusCommand = defineCommand({
       description: "Path to forgemap.config.ts (overrides walk-up discovery)"
     }
   },
-  async run({ args }) {
+  async run({ args, rawArgs }) {
     if (!ALLOWED_FORMATS.includes(args.format)) {
       consola.error(
         `Invalid --format value "${args.format}". Allowed: ${ALLOWED_FORMATS.join(", ")}.`
@@ -2591,6 +2837,7 @@ const statusCommand = defineCommand({
     if (args.forge) {
       repos = repos.filter((r) => r.forgeName === args.forge);
     }
+    repos = filterRepos(repos, resolveFilters(rawArgs, args.filter));
     if (args.query) {
       const fuse = new Fuse(repos, {
         keys: ["slug", "owner", "repo"],
@@ -2672,6 +2919,7 @@ const syncCommand = defineCommand({
       type: "string",
       description: "Restrict to a single forge alias"
     },
+    filter: filterArg,
     query: {
       type: "string",
       description: "Fuzzy filter against <owner>/<repo>"
@@ -2686,7 +2934,7 @@ const syncCommand = defineCommand({
       description: "Path to forgemap.config.ts (overrides walk-up discovery)"
     }
   },
-  async run({ args }) {
+  async run({ args, rawArgs }) {
     const loaded = await loadForgeMapConfig({ configFile: args.config });
     const configDir = loaded.configFile ? dirname(loaded.configFile) : loaded.cwd;
     let repos = await scanReposCached({
@@ -2697,6 +2945,7 @@ const syncCommand = defineCommand({
     if (args.forge) {
       repos = repos.filter((r) => r.forgeName === args.forge);
     }
+    repos = filterRepos(repos, resolveFilters(rawArgs, args.filter));
     if (args.query) {
       const fuse = new Fuse(repos, {
         keys: ["slug", "owner", "repo"],
@@ -2915,6 +3164,7 @@ const rootCommand = defineCommand({
     clone: cloneCommand,
     import: importCommand,
     cleanup: cleanupCommand,
+    delete: deleteCommand,
     cd: cdCommand,
     path: pathCommand,
     open: openCommand,