forgemap 0.4.1-dev.67-4a4bf9d → 0.4.1-dev.69-291072b

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
@@ -99,8 +100,13 @@ forgemap sync --forge work --query api  # restrict scope
 
 forgemap status                      # tree: branch / dirty / ahead↑ / behind↓ / last commit
 forgemap status --format json        # structured for jq + scripts
+
+# --filter keeps only matching owners/forges. Repeatable, OR-combined.
+forgemap status --format json --filter kirchDev --filter TitusKirch
 ```
 
+`--filter` works on `status`, `sync` and `search`. It matches an **owner** or a **forge name** exactly (case-insensitive) — unlike `--query`, which is fuzzy.
+
 All tree output (`status`, `search`, `import`) groups as `forge → owner → repo`. Network operations (`sync`, `import`, `cleanup`) run with a hard timeout and non-interactive SSH, so an unreachable host can never wedge a run.
 
 ### Adopt an existing layout — `import`

package/dist/bin/forgemap.mjs

@@ -672,6 +672,9 @@ 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) {
@@ -2050,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) {
@@ -2069,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: {
@@ -2079,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
@@ -2113,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: {
@@ -2123,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}
 `);
   }
 });
@@ -2153,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."
@@ -2176,53 +2280,58 @@ 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}
 `);
     }
   }
 });
+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) {
@@ -2263,6 +2372,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)"
@@ -2272,19 +2382,13 @@ 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 fuse = new Fuse(repos, {
-      keys: ["slug", "owner", "repo"],
-      threshold: 0.3,
-      ignoreLocation: true,
-      includeScore: true
-    });
+    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 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(
@@ -2495,6 +2599,7 @@ const statusCommand = defineCommand({
       type: "string",
       description: "Restrict to a single forge alias"
     },
+    filter: filterArg,
     query: {
       type: "string",
       description: "Fuzzy filter against <owner>/<repo>"
@@ -2509,7 +2614,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(", ")}.`
@@ -2527,6 +2632,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"],
@@ -2608,6 +2714,7 @@ const syncCommand = defineCommand({
       type: "string",
       description: "Restrict to a single forge alias"
     },
+    filter: filterArg,
     query: {
       type: "string",
       description: "Fuzzy filter against <owner>/<repo>"
@@ -2622,7 +2729,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({
@@ -2633,6 +2740,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"],