---

name: fig description: >- Fig was a macOS terminal app that showed IDE-style autocomplete for CLI commands. It shut down on 1 September 2024; its autocomplete moved into Amazon Q Developer CLI, which became the closed-source Kiro CLI in November 2025. The open completion-spec format (Fig.Spec, the withfig/autocomplete repository) still drives Kiro CLI, Microsoft inshellisense and VS Code's terminal suggestions. Use when a user asks "what happened to Fig", "what replaces Fig autocomplete", "write a Fig completion spec for my CLI", "add terminal autocomplete for our internal tool", or "move from Amazon Q CLI to Kiro CLI". license: Apache-2.0 compatibility: "Writing and compiling specs needs Node.js 18+ and npm. inshellisense runs on Linux, macOS and Windows. Kiro CLI runs on macOS, Windows 11 and Linux (glibc 2.34+ or the musl build) and needs a sign-in." metadata: author: terminal-skills version: 1.1.0 category: development repository: https://github.com/withfig/autocomplete tags:

• terminal
• autocomplete
• cli
• dotfiles
• scripts

---

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

Overview

Fig added a dropdown of subcommands, flags and arguments next to the cursor in the terminal. The product no longer exists under that name, so start by telling the user which piece of it they can still use:

Piece	Status (October 2026)
Fig app, fig CLI, fig.io	Shut down on 1 September 2024. fig.io, including its documentation, no longer answers.
Fig Scripts, Dotfiles sync, Plugins	Ended with Fig. No successor carried them over.
Amazon Q Developer CLI (q)	The open-source continuation of Fig. Since Kiro CLI appeared it only gets critical security fixes.
Kiro CLI (kiro-cli)	Current product, closed source. Has the autocomplete dropdown and inline "ghost text" suggestions, plus an AI chat agent.
Completion-spec format (Fig.Spec)	Open (MIT) in withfig/autocomplete: specs for 600+ CLIs. Last npm release @withfig/autocomplete 2.692.3, May 2025.
Runtimes that read the specs	Kiro CLI, Microsoft inshellisense (open source, all platforms), VS Code's built-in terminal suggestions.

A completion spec is a TypeScript object that declares a CLI's subcommands, options and arguments, and optionally runs commands to produce dynamic suggestions. Writing one is still the way to give an in-house CLI autocomplete in these runtimes.

Instructions

1. Find out what is installed

kiro-cli --version; q --version; is --version   # Kiro CLI, Amazon Q Developer CLI, inshellisense

The old Fig app has nothing to update to: uninstall it and pick one of the runtimes below.

2. Install a runtime

inshellisense needs no account and works over SSH because it runs inside the shell session:

npm install -g @microsoft/inshellisense
is init                  # one-time setup
is doctor                # checks the installation
is                       # start a session in the current shell; `exit` leaves it
is init zsh >> ~/.zshrc  # optional: start automatically (bash, fish, pwsh, nu, xonsh also supported)

Keep that is init line last in the shell config. Specs for aws, az and gcloud are not loaded because of their size.

Kiro CLI. The documented installer is a shell script fetched from cli.kiro.dev; Homebrew is not supported. Do not pipe it into a shell. The script only downloads a release file and compares it with a published SHA-256, which is easy to do by hand:

# Linux x86-64 with glibc 2.34+ (check with: ldd --version)
base=https://desktop-release.q.us-east-1.amazonaws.com/latest
curl --proto '=https' --tlsv1.2 -sSf "$base/kirocli-x86_64-linux.zip" -o kirocli.zip
curl --proto '=https' --tlsv1.2 -sSf "$base/kirocli-x86_64-linux.zip.sha256" -o kirocli.zip.sha256
echo "$(cat kirocli.zip.sha256)  kirocli.zip" | sha256sum -c -   # must print "kirocli.zip: OK"
unzip kirocli.zip
./kirocli/install.sh       # copies kiro-cli into ~/.local/bin and sets up shell integration
kiro-cli login
kiro-cli doctor

Other files in the same directory follow the same pattern (each has a .sha256 next to it): kirocli-aarch64-linux.zip (its installer requires glibc 2.39+), the -musl variants for older glibc, kiro-cli.deb, kiro-cli.appimage, and Kiro%20CLI.dmg for macOS (check it with shasum -a 256). On Amazon Linux 2023 use the signed RPM repository described in Kiro's installation page and sudo dnf install kiro-cli. The zip is the headless build; the .deb, AppImage and .dmg are the full desktop builds.

Autocomplete settings in Kiro CLI:

kiro-cli settings autocomplete.disable true    # turn the dropdown off (false turns it on)
kiro-cli inline enable                          # ghost-text suggestions; also: disable, status
kiro-cli theme dark                             # dropdown theme: dark, light, system
kiro-cli settings app.disableAutoupdates true

Moving from Amazon Q Developer CLI: q update replaces it with Kiro CLI. Prompts, agents and MCP settings are copied once from ~/.aws/amazonq to ~/.kiro; project .amazonq folders keep working.

3. Scaffold a spec project

mkdir shipctl-completions && cd shipctl-completions
npx @withfig/autocomplete-tools@2 init           # creates .fig/autocomplete with package.json, tsconfig, src/
cd .fig/autocomplete
npm run create-spec -- shipctl                   # writes src/shipctl.ts

Before choosing a name, check it is not already taken by a public spec: is specs list prints all of them (deployctl, for example, is Deno's CLI).

4. Write the spec

// src/shipctl.ts
const services: Fig.Generator = {
  script: ["kubectl", "get", "deployments", "-o", "name"],
  postProcess: (out) =>
    out.split("\n").filter(Boolean).map((line) => ({
      name: line.replace("deployment.apps/", ""),
      description: "Deployment in the current namespace",
    })),
  cache: { strategy: "stale-while-revalidate", ttl: 30_000 }, // milliseconds
};

const completionSpec: Fig.Spec = {
  name: "shipctl",
  description: "Deploy services to the cluster",
  subcommands: [
    {
      name: "create",
      description: "Create a new deployment",
      args: { name: "service", generators: services },
      options: [
        {
          name: ["--env", "-e"],
          description: "Target environment",
          isRequired: true,
          args: {
            name: "environment",
            suggestions: [{ name: "staging", description: "Staging cluster" }, { name: "production", description: "Production cluster" }],
          },
        },
        {
          name: ["--tag", "-t"],
          description: "Image tag",
          args: { name: "tag", generators: { script: ["git", "tag", "--sort=-version:refname"], splitOn: "\n" } },
        },
        { name: "--dry-run", description: "Print the plan and exit" },
      ],
    },
    {
      name: "rollback",
      description: "Roll a service back to an earlier revision",
      isDangerous: true,
      args: { name: "service", generators: services },
      options: [
        {
          name: "--revision",
          description: "Revision number to roll back to",
          args: {
            name: "revision",
            generators: {
              // tokens = ["shipctl", "rollback", "checkout-api", "--revision", ""]
              script: (tokens) => ["kubectl", "rollout", "history", `deployment/${tokens[2]}`],
              postProcess: (out) =>
                out.split("\n").map((line) => line.trim().split(/\s+/)[0])
                  .filter((rev) => /^\d+$/.test(rev))
                  .map((rev) => ({ name: rev, description: `Revision ${rev}` })),
            },
          },
        },
      ],
    },
    {
      name: "logs",
      description: "Show logs of a service",
      args: { name: "service", isOptional: true, generators: services },
      options: [
        { name: ["--follow", "-f"], description: "Stream new lines" },
        { name: "--since", description: "Only newer lines", args: { name: "duration", suggestions: ["5m", "1h", "24h"] } },
      ],
    },
  ],
  options: [
    { name: ["--verbose", "-v"], description: "Verbose output", isPersistent: true },
    { name: "--config", description: "Config file", isPersistent: true, args: { name: "file", template: "filepaths" } },
  ],
};

export default completionSpec;

What the parts do:

• args — positional arguments; isOptional, isVariadic and default describe them. suggestions are static values.
• generators — dynamic values. script is an array (command and arguments) or a function of the typed tokens that returns one; its stdout goes to postProcess, or to splitOn when every line is one suggestion. custom is an async function for cases that need several commands. cache avoids rerunning slow commands.
• template — built-in suggestions: "filepaths", "folders", "history", "help".
• isPersistent makes an option available in every subcommand; isRequired marks it mandatory; isDangerous on a subcommand stops the runtime from running it straight from the menu; priority (0–100) orders suggestions.

5. Check and compile

npm test type-checks every spec against @withfig/autocomplete-types; npm run build writes build/shipctl.js and build/index.js.

6. Load the spec

inshellisense reads extra spec folders from its config file, ~/.inshellisenserc (or ~/.config/inshellisense/rc.toml):

[specs]
path = ["/home/dana/shipctl-completions/.fig/autocomplete/build"]

Use an absolute path. Then is specs list includes shipctl, and typing shipctl in a new is session shows the subcommands. Rebuild and restart the session after each change.

Kiro CLI and Amazon Q. npm run dev in the spec project was Fig's developer mode: it recompiles on save and points the desktop app at build/ by calling q settings autocomplete.developerModeNPM true and q settings autocomplete.devCompletionsFolder with the build path. It was written for the macOS apps of Fig and Amazon Q and looks for a q, cw or fig binary. Kiro's documentation says nothing about custom specs, so treat this as untested there and confirm on the user's machine before promising it.

7. Generate a spec from the CLI's own definition

For a CLI built with Commander, @fig/complete-commander writes the spec from the program object:

// shipctl.mjs
import { program } from "commander";
import { addCompletionSpecCommand } from "@fig/complete-commander";

program.name("shipctl").description("Deploy services to the cluster").version("1.4.0");
program
  .command("create <service>")
  .description("Create a new deployment")
  .requiredOption("-e, --env <environment>", "Target environment")
  .option("--dry-run", "Print the plan and exit");

addCompletionSpecCommand(program);
program.parse();

npm install commander@11 @fig/complete-commander
node shipctl.mjs generate-fig-spec > src/shipctl.ts

The package declares Commander ^11.1.0 as its peer and crashes with newer major versions. Kiro CLI prints its own spec the same way: kiro-cli completion fig.

8. Autocomplete over SSH

With inshellisense, install it on the remote machine and run is there. Kiro CLI's Linux archive documents its own route in its README: install it on the server, add AcceptEnv Q_SET_PARENT and AllowStreamLocalForwarding yes to the sshd configuration, restart sshd and reconnect.

Examples

Example 1: Autocomplete for an in-house CLI

User request:

Our team has a CLI called shipctl (create, rollback, logs). Fig used to complete it for me. How do I get that back on my Linux laptop?

The agent explains that Fig itself is gone, installs inshellisense, and builds the spec from section 4:

npm install -g @microsoft/inshellisense && is init
mkdir -p ~/shipctl-completions && cd ~/shipctl-completions
npx @withfig/autocomplete-tools@2 init
cd .fig/autocomplete && npm run create-spec -- shipctl
# edit src/shipctl.ts, then:
npm test && npm run build
printf '[specs]\npath = ["%s/build"]\n' "$PWD" >> ~/.inshellisenserc
is

npm test prints All specs passed validation. and the build prints Built src/shipctl.ts. In the is session, typing shipctl opens a box listing create, rollback, logs, --verbose and --config; shipctl create checkout-api --env offers staging and production.

Example 2: Replacing Fig or Amazon Q with Kiro CLI

User request:

I still have "brew install fig" and `q login` in my setup notes for new laptops. What should they say now?

The agent replaces both lines. Fig cannot be installed any more and Amazon Q Developer CLI is in maintenance; the current tool is Kiro CLI, which Homebrew does not carry. For a Linux workstation the notes become the verified download from section 2, followed by:

kiro-cli login                 # opens the browser; --use-device-flow on a remote machine
kiro-cli doctor                # reports shell-integration problems
kiro-cli settings autocomplete.disable false
kiro-cli inline status

sha256sum -c must print kirocli.zip: OK before the archive is unpacked. kiro-cli doctor prints Not authenticated. Please run kiro-cli login until the login is done. The agent also notes what will not come back: Fig Scripts and dotfile sync have no replacement in Kiro CLI, so those belong in a dotfiles repository.

Guidelines

1. Say what is gone before giving commands — fig commands, ~/.fig/scripts, fig run and fig.io links in old tutorials no longer work.
2. Kiro CLI is not Fig with a new name — it is closed source, requires a sign-in, and is mainly an AI agent; if the user only wants completions without an account, use inshellisense or the shell's native completion.
3. script must be an array or a function — a plain string such as script: "git branch" was valid in early Fig specs and fails the type check now.
4. Generators run commands on every completion — keep them fast and read-only, add cache, and never build a command from user input with a shell (bash -c); pass tokens as separate array items.
5. Mark destructive subcommands — isDangerous: true on delete, rollback, drop.
6. Do not rely on the public spec repository for distribution — withfig/autocomplete has had no release since May 2025; ship the compiled spec with your tool or in a team repository and load it through specs.path.
7. Runtimes differ — a spec that type-checks can still behave differently in Kiro CLI, inshellisense and VS Code; test in the one the user runs.
8. Never install by piping a script into a shell — download the release file, check its SHA-256, then run it.