apigrip 0.5.4 → 0.6.2

package/cli/index.js

@@ -2,6 +2,112 @@
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 
+const METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
+
+// Intercept --get-yargs-completions before yargs to provide dynamic completions
+const rawArgs = process.argv.slice(2);
+const compIdx = rawArgs.indexOf('--get-yargs-completions');
+if (compIdx !== -1) {
+  const args = rawArgs.slice(compIdx + 1); // [apigrip, cmd, ...rest]
+  const cmd = args[1] || '';
+  const prevArg = args[args.length - 2] || '';
+  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') {
+      const { loadProjects } = await import('../core/projects-store.js');
+      const projects = loadProjects();
+      projects.forEach(p => console.log(p.name));
+      handled = true;
+    }
+
+    // -e / --env <TAB> → environment names
+    if (!handled && (prevArg === '--env' || prevArg === '-e')) {
+      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 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 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;
+        }
+      }
+    }
+  } catch {
+    // Silently fall through to yargs defaults
+  }
+
+  if (handled) process.exit(0);
+}
+
 // Register commands
 const cli = yargs(hideBin(process.argv))
   .scriptName('apigrip')
@@ -130,17 +236,19 @@ const cli = yargs(hideBin(process.argv))
   }, (argv) => {
     const shell = argv.shell || (process.env.SHELL || '').split('/').pop() || 'bash';
     if (shell === 'zsh') {
-      console.log(`#compdef apigrip
-
-_apigrip() {
-  local completions
+      console.log(`_apigrip() {
+  local -a completions
   completions=("\${(@f)$(apigrip --get-yargs-completions "\${words[@]}" 2>/dev/null)}")
-  compadd -a completions
+  local -a stripped
+  local c
+  for c in "\${completions[@]}"; do
+    stripped+=("\${c%%:*}")
+  done
+  compadd -a stripped
 }
 
-_apigrip`);
+compdef _apigrip apigrip`);
     } else {
-      // Let yargs generate bash completions by re-running with --get-yargs-completions
       console.log(`###-begin-apigrip-completions-###
 _apigrip_yargs_completions()
 {

package/completions/_apigrip

@@ -1,9 +1,14 @@
 #compdef apigrip
 
 _apigrip() {
-  local completions
+  local -a completions
   completions=("${(@f)$(apigrip --get-yargs-completions "${words[@]}" 2>/dev/null)}")
-  compadd -a completions
+  local -a stripped
+  local c
+  for c in "${completions[@]}"; do
+    stripped+=("${c%%:*}")
+  done
+  compadd -a stripped
 }
 
 _apigrip

package/package.json

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