Amazon Q (formerly Fig) — Terminal Autocomplete & CLI Tools

# Amazon Q (formerly Fig) — Terminal Autocomplete & CLI Tools


## Overview


Amazon Q Developer (formerly Fig), the terminal tool that provides IDE-style autocomplete, AI chat, and CLI builder capabilities. Helps developers create custom completion specs, build CLI tools with autocomplete, and configure terminal productivity features.


## Instructions

### Custom Completion Specs

Define autocomplete for your own CLI tools:

```typescript
// src/my-cli.ts — Completion spec for a custom CLI tool
const completionSpec: Fig.Spec = {
  name: "deploy",
  description: "Deploy services to cloud infrastructure",
  subcommands: [
    {
      name: "create",
      description: "Create a new deployment",
      args: {
        name: "service",
        description: "Service name to deploy",
        // Dynamic suggestions from an API or command output
        generators: {
          script: ["bash", "-c", "ls services/"],
          postProcess: (output) =>
            output.split("\n").filter(Boolean).map((name) => ({
              name,
              description: `Deploy ${name} service`,
              icon: "📦",
            })),
        },
      },
      options: [
        {
          name: ["--env", "-e"],
          description: "Target environment",
          args: {
            name: "environment",
            suggestions: [
              { name: "staging", description: "Staging environment", icon: "🟡" },
              { name: "production", description: "Production environment", icon: "🔴" },
              { name: "development", description: "Development environment", icon: "🟢" },
            ],
          },
          isRequired: true,
        },
        {
          name: ["--replicas", "-r"],
          description: "Number of replicas",
          args: { name: "count", default: "2" },
        },
        {
          name: "--dry-run",
          description: "Preview changes without deploying",
        },
        {
          name: ["--tag", "-t"],
          description: "Docker image tag",
          args: {
            name: "tag",
            generators: {
              // Suggest recent git tags
              script: ["bash", "-c", "git tag --sort=-version:refname | head -10"],
              postProcess: (output) =>
                output.split("\n").filter(Boolean).map((tag) => ({
                  name: tag,
                  icon: "🏷️",
                })),
            },
          },
        },
      ],
    },
    {
      name: "status",
      description: "Check deployment status",
      args: {
        name: "service",
        isOptional: true,
        generators: {
          script: ["bash", "-c", "kubectl get deployments -o jsonpath='{.items[*].metadata.name}'"],
          splitOn: " ",
        },
      },
      options: [
        {
          name: ["--watch", "-w"],
          description: "Watch status in real-time",
        },
        {
          name: "--format",
          description: "Output format",
          args: {
            suggestions: ["table", "json", "yaml"],
          },
        },
      ],
    },
    {
      name: "rollback",
      description: "Rollback to previous version",
      isDangerous: true,    // Shows warning icon
      args: {
        name: "service",
        generators: {
          script: ["bash", "-c", "kubectl get deployments -o jsonpath='{.items[*].metadata.name}'"],
          splitOn: " ",
        },
      },
      options: [
        {
          name: "--revision",
          description: "Specific revision to rollback to",
          args: {
            name: "revision",
            generators: {
              // Dynamic: list revision history for the selected service
              script: ({ tokens }) => {
                const service = tokens[2]; // deploy rollback <service>
                return ["bash", "-c", `kubectl rollout history deployment/${service} | tail -n +3 | awk '{print $1}'`];
              },
              postProcess: (output) =>
                output.split("\n").filter(Boolean).map((rev) => ({
                  name: rev,
                  description: `Revision ${rev}`,
                })),
            },
          },
        },
      ],
    },
    {
      name: "logs",
      description: "View deployment logs",
      args: {
        name: "service",
        generators: {
          script: ["bash", "-c", "kubectl get deployments -o jsonpath='{.items[*].metadata.name}'"],
          splitOn: " ",
        },
      },
      options: [
        { name: ["--follow", "-f"], description: "Stream logs in real-time" },
        { name: "--since", description: "Show logs since duration", args: { suggestions: ["1m", "5m", "1h", "24h"] } },
        { name: "--tail", description: "Number of recent lines", args: { name: "lines", default: "100" } },
      ],
    },
  ],
  options: [
    {
      name: ["--verbose", "-v"],
      description: "Enable verbose output",
      isPersistent: true,    // Available on all subcommands
    },
    {
      name: "--config",
      description: "Path to config file",
      isPersistent: true,
      args: { template: "filepaths" },   // File path autocomplete
    },
  ],
};

export default completionSpec;
```

### Dotfile Scripts

Create portable shell scripts that run across machines:

```bash
# ~/.fig/scripts/setup-project.sh — Reusable project setup script
#!/bin/bash
# Fig script: Initialize a new TypeScript project with standard tooling

set -euo pipefail

PROJECT_NAME=${1:?"Usage: fig run setup-project <name>"}

echo "📁 Creating project: $PROJECT_NAME"
mkdir -p "$PROJECT_NAME" && cd "$PROJECT_NAME"

# Initialize with package.json
cat > package.json << EOF
{
  "name": "$PROJECT_NAME",
  "version": "0.1.0",
  "type": "module",
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "build": "tsup src/index.ts",
    "lint": "biome check .",
    "format": "biome format --write .",
    "test": "vitest"
  }
}
EOF

# Install dependencies
pnpm install typescript tsx tsup vitest @biomejs/biome

# TypeScript config
cat > tsconfig.json << 'EOF'
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "outDir": "dist",
    "rootDir": "src",
    "declaration": true
  },
  "include": ["src"]
}
EOF

# Biome config
cat > biome.json << 'EOF'
{
  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
  "organizeImports": { "enabled": true },
  "linter": { "enabled": true },
  "formatter": { "indentStyle": "space", "indentWidth": 2 }
}
EOF

# Create entry point
mkdir -p src
cat > src/index.ts << 'EOF'
console.log("Hello from $PROJECT_NAME!");
EOF

# Git init
git init
echo "node_modules/\ndist/\n.env" > .gitignore

echo "✅ Project $PROJECT_NAME created!"
echo "   cd $PROJECT_NAME && pnpm dev"
```

### SSH Integration

Auto-complete for remote servers:

```typescript
// src/ssh-hosts.ts — Dynamic SSH host suggestions
const sshSpec: Fig.Spec = {
  name: "ssh",
  args: {
    name: "destination",
    generators: {
      // Parse SSH config for host suggestions
      script: ["bash", "-c", `
        grep "^Host " ~/.ssh/config 2>/dev/null | awk '{print $2}' | grep -v '*'
      `],
      postProcess: (output) =>
        output.split("\n").filter(Boolean).map((host) => ({
          name: host,
          description: "SSH host from config",
          icon: "🖥️",
          priority: 80,
        })),
    },
  },
};
```

## Installation

```bash
# macOS
brew install amazon-q

# Or direct download from https://aws.amazon.com/q/developer/

# Login and configure
q login
q settings
```


## Examples


### Example 1: Setting up Fig with a custom configuration

**User request:**

```
I just installed Fig. Help me configure it for my TypeScript + React workflow with my preferred keybindings.
```

The agent creates the configuration file with TypeScript-aware settings, configures relevant plugins/extensions for React development, sets up keyboard shortcuts matching the user's preferences, and verifies the setup works correctly.

### Example 2: Extending Fig with custom functionality

**User request:**

```
I want to add a custom dotfile scripts to Fig. How do I build one?
```

The agent scaffolds the extension/plugin project, implements the core functionality following Fig's API patterns, adds configuration options, and provides testing instructions to verify it works end-to-end.


## Guidelines

1. **Generators for dynamic suggestions** — Use shell scripts to generate suggestions from live data (git branches, k8s resources, file lists)
2. **Mark dangerous commands** — Set `isDangerous: true` on destructive subcommands (delete, drop, rollback)
3. **Use templates for common arg types** — `template: "filepaths"` for file args, `template: "folders"` for directories
4. **Persistent options** — Use `isPersistent: true` for flags like `--verbose` that apply to all subcommands
5. **Icons and descriptions** — Add icons and descriptions to suggestions; visual cues speed up selection
6. **Publish to the spec repo** — Share your completion specs via the fig/autocomplete GitHub repo for community use
7. **Test with `fig settings developer.enabled true`** — Enable developer mode for spec debugging and hot reload
8. **Dotfile scripts for portability** — Store setup scripts in `~/.fig/scripts/`; they sync across machines via Fig's dotfile management