forgemap 0.4.1-dev.66-903324b → 0.4.1-dev.68-66824fb

package/README.md

@@ -83,7 +83,8 @@ forgemap pick kirch                 # picker pre-filtered by fuzzy query
 ### Open the folder in the OS file manager
 
 ```bash
-forgemap open kirchDev/laravel-pbac
+forgemap open kirchDev/laravel-pbac      # exact slug
+forgemap open laravel                    # fuzzy single match → same folder
 ```
 
 - **WSL** → launches `explorer.exe` against `\\wsl$\<distro>\…`, Explorer opens the folder
@@ -123,10 +124,10 @@ For each repo `import` compares the folder's `<owner>/<repo>` against the git `o
 forgemap cleanup                     # list deletable clones, then type "yes" to confirm
 forgemap cleanup --dry-run           # show candidates + why every other idle repo is kept
 forgemap cleanup --days 540          # idle threshold in days (default 365)
-forgemap cleanup --include-dirty --include-unpushed   # also delete repos with local-only work (lost!)
+forgemap cleanup --include-dirty --include-unpushed --include-stashed   # also delete repos with local-only work (lost!)
 ```
 
-A repo is only deleted when it is idle for `--days`+ days (by last **local** commit), has a clean working tree, has nothing unpushed, **and** its remote still exists — so everything removed is provably backed up. Repos without a remote (or with a gone/unreachable one) are never touched; empty owner directories left behind are pruned automatically. Deletion needs an explicit typed `yes` (or `--yes`).
+A repo is only deleted when it is idle for `--days`+ days (by last **local** commit), has a clean working tree, has nothing unpushed, has no stashed work, **and** its remote still exists — so everything removed is provably backed up. Repos without a remote (or with a gone/unreachable one) are never touched; empty owner directories left behind are pruned automatically. Deletion needs an explicit typed `yes` (or `--yes`).
 
 ### Preflight your config
 

package/dist/bin/forgemap.mjs

@@ -568,6 +568,7 @@ async function getRepoStatus(localPath) {
     dirty: false,
     ahead: 0,
     behind: 0,
+    stashes: 0,
     lastCommit: null
   };
   const branchResult = await gitIn(localPath, ["branch", "--show-current"]);
@@ -575,6 +576,7 @@ async function getRepoStatus(localPath) {
   status.detached = !status.branch || status.branch === "HEAD";
   const porcelain = await gitIn(localPath, ["status", "--porcelain"]);
   status.dirty = porcelain.stdout.trim().length > 0;
+  status.stashes = await countStashes(localPath);
   const aheadBehind = await gitIn(localPath, [
     "rev-list",
     "--left-right",
@@ -659,12 +661,20 @@ async function hasUnpushedCommits(localPath) {
   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) {
@@ -723,6 +733,7 @@ async function evaluate(repo, cutoffUnix) {
   if (lastCommitUnix === null || lastCommitUnix > cutoffUnix) return null;
   const status = await getRepoStatus(repo.localPath);
   const dirty = status.dirty;
+  const stashes = status.stashes;
   const unpushed = await hasUnpushedCommits(repo.localPath);
   let owner = repo.owner;
   let name = repo.repo;
@@ -732,7 +743,16 @@ async function evaluate(repo, cutoffUnix) {
     name = parsed.repo;
   } catch {
   }
-  return { repo, origin, owner, name, lastCommitUnix, dirty, unpushed };
+  return {
+    repo,
+    origin,
+    owner,
+    name,
+    lastCommitUnix,
+    dirty,
+    unpushed,
+    stashes
+  };
 }
 async function classifyRemotes(candidates) {
   const byType = /* @__PURE__ */ new Map();
@@ -832,6 +852,11 @@ const cleanupCommand = defineCommand({
       description: "Also delete repos with unpushed commits (those commits are lost)",
       default: false
     },
+    "include-stashed": {
+      type: "boolean",
+      description: "Also delete repos with stashed work (that stash is lost)",
+      default: false
+    },
     "no-cache": {
       type: "boolean",
       description: "Skip the scanned-repos cache",
@@ -865,7 +890,8 @@ const cleanupCommand = defineCommand({
     )).filter((c) => c !== null);
     const includeDirty = Boolean(args["include-dirty"]);
     const includeUnpushed = Boolean(args["include-unpushed"]);
-    const localOk = (c) => (!c.dirty || includeDirty) && (!c.unpushed || includeUnpushed);
+    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 candidates = [];
     const kept = [];
@@ -874,6 +900,11 @@ const cleanupCommand = defineCommand({
         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);
@@ -896,7 +927,8 @@ const cleanupCommand = defineCommand({
       for (const c of candidates) {
         const flags = [
           c.dirty ? colors.red("dirty") : "",
-          c.unpushed ? colors.red("unpushed") : ""
+          c.unpushed ? colors.red("unpushed") : "",
+          c.stashes > 0 ? colors.red(`stashed:${c.stashes}`) : ""
         ].filter(Boolean).join(" ");
         process.stdout.write(
           `  ${colors.cyan(`${c.repo.forgeName}:${c.repo.slug}`)}  ${colors.dim(`${ageDays(c.lastCommitUnix)}d idle`)}${flags ? `  ${flags}` : ""}  ${colors.dim(c.repo.localPath)}
@@ -938,10 +970,12 @@ const cleanupCommand = defineCommand({
       return;
     }
     if (candidates.length > 0) {
-      const losing = candidates.filter((c) => c.dirty || c.unpushed).length;
+      const losing = candidates.filter(
+        (c) => c.dirty || c.unpushed || c.stashes > 0
+      ).length;
       if (losing > 0) {
         consola.warn(
-          `${losing} of these have uncommitted/unpushed work that will be permanently lost.`
+          `${losing} of these have uncommitted/unpushed/stashed work that will be permanently lost.`
         );
       }
       let confirmed = args.yes;
@@ -2019,6 +2053,111 @@ const importCommand = defineCommand({
     });
   }
 });
+const REPO_FUSE_OPTIONS = {
+  keys: ["slug", "owner", "repo"],
+  threshold: 0.3,
+  ignoreLocation: true
+};
+function createRepoFuse(repos) {
+  return new Fuse(repos, REPO_FUSE_OPTIONS);
+}
+function matchRepos(repos, query, limit) {
+  const fuse = createRepoFuse(repos);
+  const results = fuse.search(query, limit ? { limit } : void 0);
+  return results.map((r) => r.item);
+}
+async function promptRepoChoice(candidates) {
+  const out = process.stdout;
+  const realWrite = out.write;
+  const saved = {
+    rows: Object.getOwnPropertyDescriptor(out, "rows"),
+    columns: Object.getOwnPropertyDescriptor(out, "columns"),
+    isTTY: Object.getOwnPropertyDescriptor(out, "isTTY")
+  };
+  const fake = (key, value) => {
+    Object.defineProperty(out, key, { configurable: true, value });
+  };
+  const restore = (key) => {
+    if (saved[key]) Object.defineProperty(out, key, saved[key]);
+    else delete out[key];
+  };
+  out.write = process.stderr.write.bind(process.stderr);
+  fake("rows", process.stderr.rows ?? 24);
+  fake("columns", process.stderr.columns ?? 80);
+  fake("isTTY", true);
+  let choice;
+  try {
+    choice = await consola.prompt("Select a repo", {
+      type: "select",
+      options: candidates.map((r) => ({
+        label: `${colors.gray(`${r.forgeName}:`)}${r.slug}`,
+        value: r.localPath,
+        hint: r.localPath
+      }))
+    });
+  } finally {
+    out.write = realWrite;
+    restore("rows");
+    restore("columns");
+    restore("isTTY");
+  }
+  return typeof choice === "string" && choice ? choice : void 0;
+}
+function canPrompt() {
+  return Boolean(process.stdin.isTTY);
+}
+async function locateRepo(input, options) {
+  const { config, configDir } = options;
+  if (!input.trim() || looksLikeSlug(input)) {
+    const resolved = resolveSlug(parseSlug(input), { config, configDir });
+    return { kind: "slug", localPath: resolved.localPath };
+  }
+  const repos = options.repos ?? await scanRepos({ config, configDir });
+  const candidates = matchRepos(repos, input);
+  if (candidates.length === 0) return { kind: "none", query: input };
+  if (candidates.length === 1) {
+    return {
+      kind: "match",
+      localPath: candidates[0].localPath,
+      repo: candidates[0]
+    };
+  }
+  return { kind: "ambiguous", query: input, candidates };
+}
+async function resolveRepoPath(input, options) {
+  const outcome = await locateRepo(input, options);
+  switch (outcome.kind) {
+    case "slug":
+    case "match":
+      return outcome.localPath;
+    case "none":
+      consola.error(`No cloned repo matches "${outcome.query}".`);
+      process.stderr.write(
+        `${colors.dim("Pass an explicit <owner>/<repo> for a repo that is not cloned yet.")}
+`
+      );
+      return null;
+    case "ambiguous": {
+      if (canPrompt()) {
+        return await promptRepoChoice(outcome.candidates) ?? null;
+      }
+      consola.error(
+        `"${outcome.query}" matches ${outcome.candidates.length} cloned repos:`
+      );
+      for (const c of outcome.candidates) {
+        process.stderr.write(
+          `  ${colors.cyan(`${c.forgeName}:${c.slug}`)}  ${colors.dim(c.localPath)}
+`
+        );
+      }
+      process.stderr.write(
+        `${colors.dim("Narrow the query, pass an explicit <owner>/<repo>, or run `forgemap pick` to choose interactively.")}
+`
+      );
+      return null;
+    }
+  }
+}
 function platformOpen(localPath) {
   const distro = process.env.WSL_DISTRO_NAME;
   if (distro) {
@@ -2038,7 +2177,7 @@ const openCommand = defineCommand({
   args: {
     slug: {
       type: "positional",
-      description: "owner/repo, forge:owner/repo, or full URL",
+      description: "owner/repo, forge:owner/repo, full URL, or a fuzzy query matched against cloned repos",
       required: true
     },
     config: {
@@ -2048,14 +2187,17 @@ const openCommand = defineCommand({
   },
   async run({ args }) {
     const loaded = await loadForgeMapConfig({ configFile: args.config });
-    const parsed = parseSlug(args.slug);
     const configDir = loaded.configFile ? dirname(loaded.configFile) : loaded.cwd;
-    const resolved = resolveSlug(parsed, {
+    const localPath = await resolveRepoPath(args.slug, {
       config: loaded.config,
       configDir
     });
-    const { cmd, args: cmdArgs } = platformOpen(resolved.localPath);
-    consola.info(`Opening ${resolved.localPath}`);
+    if (!localPath) {
+      process.exitCode = 1;
+      return;
+    }
+    const { cmd, args: cmdArgs } = platformOpen(localPath);
+    consola.info(`Opening ${localPath}`);
     const child = spawn(cmd, cmdArgs, {
       stdio: "ignore",
       detached: true
@@ -2082,7 +2224,7 @@ const pathCommand = defineCommand({
   args: {
     slug: {
       type: "positional",
-      description: "owner/repo, forge:owner/repo, or full URL",
+      description: "owner/repo, forge:owner/repo, full URL, or a fuzzy query matched against cloned repos",
       required: true
     },
     config: {
@@ -2092,13 +2234,16 @@ const pathCommand = defineCommand({
   },
   async run({ args }) {
     const loaded = await loadForgeMapConfig({ configFile: args.config });
-    const parsed = parseSlug(args.slug);
     const configDir = loaded.configFile ? dirname(loaded.configFile) : loaded.cwd;
-    const resolved = resolveSlug(parsed, {
+    const localPath = await resolveRepoPath(args.slug, {
       config: loaded.config,
       configDir
     });
-    process.stdout.write(`${resolved.localPath}
+    if (!localPath) {
+      process.exitCode = 1;
+      return;
+    }
+    process.stdout.write(`${localPath}
 `);
   }
 });
@@ -2122,17 +2267,7 @@ const pickCommand = defineCommand({
     const loaded = await loadForgeMapConfig({ configFile: args.config });
     const configDir = loaded.configFile ? dirname(loaded.configFile) : loaded.cwd;
     const all = await scanRepos({ config: loaded.config, configDir });
-    let candidates;
-    if (args.query) {
-      const fuse = new Fuse(all, {
-        keys: ["slug", "owner", "repo"],
-        threshold: 0.3,
-        ignoreLocation: true
-      });
-      candidates = fuse.search(args.query).map((r) => r.item);
-    } else {
-      candidates = all;
-    }
+    const candidates = args.query ? matchRepos(all, args.query) : all;
     if (candidates.length === 0) {
       consola.error(
         args.query ? `No repos match "${args.query}".` : "No repos found under the configured root."
@@ -2145,49 +2280,16 @@ const pickCommand = defineCommand({
 `);
       return;
     }
-    if (!process.stdin.isTTY) {
+    if (!canPrompt()) {
       consola.error(
         "pick requires an interactive terminal. Use `forgemap search` for non-interactive output."
       );
       process.exitCode = 1;
       return;
     }
-    const out = process.stdout;
-    const realWrite = out.write;
-    const saved = {
-      rows: Object.getOwnPropertyDescriptor(out, "rows"),
-      columns: Object.getOwnPropertyDescriptor(out, "columns"),
-      isTTY: Object.getOwnPropertyDescriptor(out, "isTTY")
-    };
-    const fake = (key, value) => {
-      Object.defineProperty(out, key, { configurable: true, value });
-    };
-    const restore = (key) => {
-      if (saved[key]) Object.defineProperty(out, key, saved[key]);
-      else delete out[key];
-    };
-    out.write = process.stderr.write.bind(process.stderr);
-    fake("rows", process.stderr.rows ?? 24);
-    fake("columns", process.stderr.columns ?? 80);
-    fake("isTTY", true);
-    let choice;
-    try {
-      choice = await consola.prompt("Select a repo", {
-        type: "select",
-        options: candidates.map((r) => ({
-          label: `${colors.gray(`${r.forgeName}:`)}${r.slug}`,
-          value: r.localPath,
-          hint: r.localPath
-        }))
-      });
-    } finally {
-      out.write = realWrite;
-      restore("rows");
-      restore("columns");
-      restore("isTTY");
-    }
-    if (typeof choice === "string" && choice) {
-      realWrite.call(out, `${choice}
+    const choice = await promptRepoChoice(candidates);
+    if (choice) {
+      process.stdout.write(`${choice}
 `);
     }
   }
@@ -2245,15 +2347,8 @@ const searchCommand = defineCommand({
     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 fuse = new Fuse(repos, {
-      keys: ["slug", "owner", "repo"],
-      threshold: 0.3,
-      ignoreLocation: true,
-      includeScore: true
-    });
     const limit = args.limit ? Number.parseInt(args.limit, 10) : void 0;
-    const results = fuse.search(args.query, limit ? { limit } : void 0);
-    const items = results.map((r) => r.item);
+    const items = matchRepos(repos, args.query, limit);
     const allowed = ["auto", "pretty", "path", "slug"];
     if (!allowed.includes(args.format)) {
       consola.error(
@@ -2419,6 +2514,7 @@ function statusLine(row) {
   if (s.behind > 0) aheadBehind.push(colors.yellow(`↓${s.behind}`));
   if (aheadBehind.length > 0) parts.push(aheadBehind.join(" "));
   parts.push(s.dirty ? colors.red("●") : colors.green("✓"));
+  if (s.stashes > 0) parts.push(colors.yellow(`⚑${s.stashes}`));
   parts.push(colors.gray(s.branch));
   if (s.lastCommit) {
     parts.push(colors.dim(`${s.lastCommit.sha} ${s.lastCommit.relativeDate}`));