apigrip 0.6.1 → 0.6.2

package/cli/index.js

@@ -14,6 +14,43 @@ if (compIdx !== -1) {
   const cmdsWithMethod = ['send', 'curl', 'show', 'last'];
   let handled = false;
 
+  // Extract --project <name> or --spec <path> from args to resolve the right project
+  function getArgValue(flag) {
+    const idx = args.indexOf(flag);
+    return (idx !== -1 && idx + 1 < args.length) ? args[idx + 1] : null;
+  }
+
+  // Resolve project dir from --project name, --spec path, or cwd
+  async function resolveProjectDir() {
+    const { loadProjects, findProjectForDir } = await import('../core/projects-store.js');
+    const projectName = getArgValue('--project');
+    const specFlag = getArgValue('--spec');
+    if (specFlag) {
+      const { dirname } = await import('node:path');
+      return getArgValue('--project')
+        ? loadProjects().find(p => p.name === projectName)?.path || process.cwd()
+        : dirname(specFlag);
+    }
+    if (projectName) {
+      const match = loadProjects().find(p => p.name === projectName);
+      if (match) return match.path;
+    }
+    const cwdMatch = findProjectForDir(process.cwd());
+    return cwdMatch ? cwdMatch.path : process.cwd();
+  }
+
+  // Discover and parse spec, returning endpoints
+  async function resolveEndpoints() {
+    const { discoverSpec } = await import('../core/spec-discovery.js');
+    const { parseSpec, extractEndpoints } = await import('../core/spec-parser.js');
+    const projectDir = await resolveProjectDir();
+    const specFlag = getArgValue('--spec');
+    const specPath = specFlag || (await discoverSpec(projectDir))?.specPath;
+    if (!specPath) return [];
+    const spec = await parseSpec(specPath);
+    return extractEndpoints(spec);
+  }
+
   try {
     // --project <TAB> → bookmarked project names
     if (prevArg === '--project') {
@@ -25,55 +62,43 @@ if (compIdx !== -1) {
 
     // -e / --env <TAB> → environment names
     if (!handled && (prevArg === '--env' || prevArg === '-e')) {
-      const { findProjectForDir } = await import('../core/projects-store.js');
-      const match = findProjectForDir(process.cwd());
-      if (match) {
-        const { loadEnvironments } = await import('../core/env-resolver.js');
-        const envData = loadEnvironments(match.path);
-        Object.keys(envData.environments || {}).forEach(n => console.log(n));
-      }
+      const { loadEnvironments } = await import('../core/env-resolver.js');
+      const projectDir = await resolveProjectDir();
+      const envData = loadEnvironments(projectDir);
+      Object.keys(envData.environments || {}).forEach(n => console.log(n));
       handled = true;
     }
 
     // --tag <TAB> → tag names from spec
     if (!handled && prevArg === '--tag') {
-      const { findProjectForDir } = await import('../core/projects-store.js');
-      const { discoverSpec } = await import('../core/spec-discovery.js');
-      const { parseSpec, extractEndpoints } = await import('../core/spec-parser.js');
-      const match = findProjectForDir(process.cwd());
-      const result = match ? await discoverSpec(match.path) : await discoverSpec(process.cwd());
-      const specPath = result?.specPath || result;
-      if (specPath) {
-        const spec = await parseSpec(specPath);
-        const endpoints = extractEndpoints(spec);
-        const tags = new Set();
-        endpoints.forEach(e => (e.tags || []).forEach(t => tags.add(t)));
-        tags.forEach(t => console.log(t));
-      }
+      const endpoints = await resolveEndpoints();
+      const tags = new Set();
+      endpoints.forEach(e => (e.tags || []).forEach(t => tags.add(t)));
+      tags.forEach(t => console.log(t));
       handled = true;
     }
 
     // Commands with <method> <path>: complete methods, then endpoint paths
+    // Use pattern matching (not positional counting) to handle interspersed options
     if (!handled && cmdsWithMethod.includes(cmd)) {
-      const positionals = args.slice(2).filter(a => !a.startsWith('-'));
-      if (positionals.length <= 1) {
-        METHODS.forEach(m => console.log(m));
-        handled = true;
-      } else if (positionals.length === 2) {
-        const { findProjectForDir } = await import('../core/projects-store.js');
-        const { discoverSpec } = await import('../core/spec-discovery.js');
-        const { parseSpec, extractEndpoints } = await import('../core/spec-parser.js');
-        const match = findProjectForDir(process.cwd());
-        const result = match ? await discoverSpec(match.path) : await discoverSpec(process.cwd());
-        const specPath = result?.specPath || result;
-        if (specPath) {
-          const spec = await parseSpec(specPath);
-          const endpoints = extractEndpoints(spec);
-          const method = positionals[0]?.toUpperCase();
-          const filtered = method ? endpoints.filter(e => e.method === method) : endpoints;
+      const currentWord = args[args.length - 1] || '';
+      // If user is typing an option flag, let yargs handle it
+      if (!currentWord.startsWith('-')) {
+        // Look at all args except the current word being completed
+        const prior = args.slice(2, -1);
+        const methodArg = prior.find(a => METHODS.includes(a.toUpperCase()));
+        const pathArg = prior.find(a => a.startsWith('/'));
+
+        if (!methodArg) {
+          METHODS.forEach(m => console.log(m));
+          handled = true;
+        } else if (!pathArg) {
+          const endpoints = await resolveEndpoints();
+          const method = methodArg.toUpperCase();
+          const filtered = endpoints.filter(e => e.method === method);
           filtered.forEach(e => console.log(e.path));
+          handled = true;
         }
-        handled = true;
       }
     }
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apigrip",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "A spec-first, read-only OpenAPI client for developers",
   "type": "module",
   "main": "./lib/index.cjs",