aish-cli 1.0.0 → 1.1.1

package/aish.plugin.zsh

@@ -0,0 +1,427 @@
+# aish - AI Shell Integration for Zsh
+# Press Ctrl+G to convert natural language to shell commands
+
+# Check if aish is installed
+if ! command -v aish &>/dev/null; then
+  print -P "%F{yellow}[aish]%f aish command not found. Install with: npm install -g aish-cli"
+  return 1
+fi
+
+# History file
+AISH_HISTFILE="${AISH_HISTFILE:-$HOME/.aish_history}"
+AISH_HISTSIZE="${AISH_HISTSIZE:-100}"
+
+# Shared state
+typeset -g _aish_input_query=""
+
+# Load history into array
+typeset -ga _aish_history
+_aish_load_history() {
+  _aish_history=()
+  [[ -f "$AISH_HISTFILE" ]] && _aish_history=("${(@f)$(< "$AISH_HISTFILE")}")
+}
+
+_aish_save_history() {
+  local entry="$1"
+  [[ -z "$entry" ]] && return
+  _aish_history=("${(@)_aish_history:#$entry}")
+  _aish_history+=("$entry")
+  while (( ${#_aish_history} > AISH_HISTSIZE )); do
+    shift _aish_history
+  done
+  printf '%s\n' "${_aish_history[@]}" > "$AISH_HISTFILE"
+}
+
+_aish_load_history
+
+# Fill placeholders like <message>, <url>, etc.
+# Sets _aish_input_query with result, returns 1 if cancelled
+_aish_fill_placeholders() {
+  local cmd="$1"
+  local result="$cmd"
+
+  # Find all unique placeholders
+  local placeholders=()
+  local seen=()
+  while [[ "$result" =~ '<([^>]+)>' ]]; do
+    local match="${MATCH}"
+    local name="${match:1:-1}"
+
+    # Check if already seen
+    local found=0
+    for s in "${seen[@]}"; do
+      [[ "$s" == "$match" ]] && found=1 && break
+    done
+
+    if (( !found )); then
+      seen+=("$match")
+      placeholders+=("$match:$name")
+    fi
+
+    # Move past this match
+    result="${result#*$match}"
+  done
+
+  result="$cmd"
+
+  # If no placeholders, return as-is
+  if (( ${#placeholders[@]} == 0 )); then
+    _aish_input_query="$cmd"
+    return 0
+  fi
+
+  # Prompt for each placeholder
+  local total=${#placeholders[@]}
+  local current=0
+
+  for entry in "${placeholders[@]}"; do
+    (( current++ ))
+    local placeholder="${entry%%:*}"
+    local name="${entry#*:}"
+
+    # Read the value with inline display
+    local value=""
+    local vcursor=0
+    local char
+
+    # Helper to update display with current value
+    _aish_placeholder_display() {
+      # Replace first occurrence of placeholder with value for display
+      local before="${result%%$placeholder*}"
+      local after="${result#*$placeholder}"
+      local display_val="$value"
+      [[ -z "$display_val" ]] && display_val="$placeholder"
+
+      BUFFER="${before}${display_val}${after}"
+      CURSOR=$(( ${#before} + vcursor ))
+
+      POSTDISPLAY=$'\n  '"$name ($current/$total)"'  │  enter: continue  │  esc: cancel'
+      region_highlight=()
+
+      # Highlight the value/placeholder area
+      local start=${#before}
+      local end=$(( start + ${#display_val} ))
+      if [[ -z "$value" ]]; then
+        region_highlight+=("${start} ${end} fg=yellow,bold")
+      else
+        region_highlight+=("${start} ${end} fg=green")
+      fi
+
+      # Dim the hint text
+      local hint_start=${#BUFFER}
+      local hint_end=$(( hint_start + ${#POSTDISPLAY} ))
+      region_highlight+=("${hint_start} ${hint_end} fg=8")
+
+      zle -R
+    }
+
+    _aish_placeholder_display
+
+    while read -k1 char; do
+      # Handle escape sequences (arrow keys)
+      if [[ "$char" == $'\e' ]]; then
+        read -k1 -t 0.1 char2
+        if [[ "$char2" == '[' ]]; then
+          read -k1 -t 0.1 char3
+          case "$char3" in
+            C) (( vcursor < ${#value} )) && (( vcursor++ )) ;;  # Right
+            D) (( vcursor > 0 )) && (( vcursor-- )) ;;          # Left
+          esac
+          _aish_placeholder_display
+          continue
+        else
+          # Escape key - cancel
+          _aish_input_query=""
+          POSTDISPLAY=""
+          return 1
+        fi
+      fi
+
+      case "$char" in
+        $'\n'|$'\r')
+          break ;;
+        $'\x7f'|$'\b')
+          if (( vcursor > 0 )); then
+            value="${value:0:$((vcursor-1))}${value:$vcursor}"
+            (( vcursor-- ))
+          fi ;;
+        $'\x03')
+          _aish_input_query=""
+          POSTDISPLAY=""
+          return 1 ;;
+        $'\x01') vcursor=0 ;;           # Ctrl+A
+        $'\x05') vcursor=${#value} ;;   # Ctrl+E
+        *)
+          value="${value:0:$vcursor}${char}${value:$vcursor}"
+          (( vcursor++ )) ;;
+      esac
+      _aish_placeholder_display
+    done
+
+    unset -f _aish_placeholder_display
+
+    # Cancel if empty value
+    if [[ -z "$value" ]]; then
+      _aish_input_query=""
+      POSTDISPLAY=""
+      return 1
+    fi
+
+    # Replace all occurrences of this placeholder
+    result="${result//$placeholder/$value}"
+  done
+
+  POSTDISPLAY=""
+  _aish_input_query="$result"
+  return 0
+}
+
+_aish_update_display() {
+  local prefix="$1"
+  local query="$2"
+  local qcursor="$3"
+
+  BUFFER="${prefix}${query}"
+  CURSOR=$(( ${#prefix} + qcursor ))
+  region_highlight=("0 ${#prefix} fg=magenta,bold")
+  zle -R
+}
+
+_aish_read_input() {
+  local prefix="$1"
+  local initial_query="${2:-}"
+
+  local query="$initial_query"
+  local qcursor=${#query}
+  local char
+  local hist_idx=$(( ${#_aish_history} + 1 ))
+  local saved_query=""
+
+  _aish_update_display "$prefix" "$query" "$qcursor"
+
+  while read -k1 char; do
+    if [[ "$char" == $'\e' ]]; then
+      read -k1 -t 0.1 char2
+      if [[ "$char2" == '[' ]]; then
+        read -k1 -t 0.1 char3
+        case "$char3" in
+          A) # Up
+            if (( hist_idx > 1 )); then
+              (( hist_idx == ${#_aish_history} + 1 )) && saved_query="$query"
+              (( hist_idx-- ))
+              query="${_aish_history[$hist_idx]}"
+              qcursor=${#query}
+            fi ;;
+          B) # Down
+            if (( hist_idx <= ${#_aish_history} )); then
+              (( hist_idx++ ))
+              if (( hist_idx > ${#_aish_history} )); then
+                query="$saved_query"
+              else
+                query="${_aish_history[$hist_idx]}"
+              fi
+              qcursor=${#query}
+            fi ;;
+          C) (( qcursor < ${#query} )) && (( qcursor++ )) ;;
+          D) (( qcursor > 0 )) && (( qcursor-- )) ;;
+        esac
+        _aish_update_display "$prefix" "$query" "$qcursor"
+        continue
+      else
+        _aish_input_query=""
+        return 1
+      fi
+    fi
+
+    case "$char" in
+      $'\n'|$'\r')
+        _aish_input_query="$query"
+        return 0 ;;
+      $'\x7f'|$'\b')
+        if (( qcursor > 0 )); then
+          query="${query:0:$((qcursor-1))}${query:$qcursor}"
+          (( qcursor-- ))
+        fi ;;
+      $'\x03')
+        _aish_input_query=""
+        return 1 ;;
+      $'\x01') qcursor=0 ;;
+      $'\x05') qcursor=${#query} ;;
+      $'\x15') query=""; qcursor=0 ;;
+      *)
+        query="${query:0:$qcursor}${char}${query:$qcursor}"
+        (( qcursor++ ))
+        hist_idx=$(( ${#_aish_history} + 1 )) ;;
+    esac
+    _aish_update_display "$prefix" "$query" "$qcursor"
+  done
+}
+
+_aish_widget() {
+  setopt LOCAL_OPTIONS NO_NOTIFY NO_MONITOR
+
+  local cmd
+  local saved_buffer="$BUFFER"
+  local saved_cursor="$CURSOR"
+  local saved_region_highlight=("${region_highlight[@]}")
+  local context=""
+
+  while true; do
+    local prefix="AI› "
+    [[ -n "$context" ]] && prefix="AI+ "
+
+    if ! _aish_read_input "$prefix" ""; then
+      region_highlight=("${saved_region_highlight[@]}")
+      BUFFER="$saved_buffer"
+      CURSOR="$saved_cursor"
+      zle -R
+      return
+    fi
+
+    local query="$_aish_input_query"
+
+    if [[ -z "$query" ]]; then
+      region_highlight=("${saved_region_highlight[@]}")
+      BUFFER="$saved_buffer"
+      CURSOR="$saved_cursor"
+      zle -R
+      return
+    fi
+
+    # Build query with context
+    local full_query="$query"
+    if [[ -n "$context" ]]; then
+      full_query="Previous conversation:
+${context}
+
+User's new request: $query
+
+Respond with only the updated command."
+    fi
+
+    # Show spinner in buffer while loading
+    local spinner='⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
+    local spin_i=0
+    local tmpfile=$(mktemp)
+    local errfile=$(mktemp)
+
+    # Hide cursor
+    print -n $'\e[?25l'
+
+    aish --print "$full_query" > "$tmpfile" 2>"$errfile" &
+    local pid=$!
+
+    while kill -0 $pid 2>/dev/null; do
+      local spin_char="${spinner:$spin_i:1}"
+      BUFFER="${prefix}${query} ${spin_char}"
+      CURSOR=${#BUFFER}
+      region_highlight=("0 ${#prefix} fg=magenta,bold")
+      zle -R
+      spin_i=$(( (spin_i + 1) % 10 ))
+      sleep 0.08
+    done
+
+    # Show cursor
+    print -n $'\e[?25h'
+
+    wait $pid 2>/dev/null
+    local exit_code=$?
+    cmd=$(<"$tmpfile")
+    local stats=$(<"$errfile")
+    rm -f "$tmpfile" "$errfile"
+
+    # Strip ANSI codes from stats for clean display
+    stats="${stats//$'\e[2m'/}"
+    stats="${stats//$'\e[0m'/}"
+    stats="${stats## }"  # trim leading space
+    stats="${stats%%$'\n'}"  # trim trailing newline
+
+    if [[ $exit_code -ne 0 ]]; then
+      # Show error briefly
+      BUFFER=""
+      POSTDISPLAY=$'\n  '"Error: ${stats:-aish command failed}"
+      region_highlight=()
+      zle -R
+      sleep 2
+      POSTDISPLAY=""
+      region_highlight=("${saved_region_highlight[@]}")
+      BUFFER="$saved_buffer"
+      CURSOR="$saved_cursor"
+      zle -R
+      return
+    fi
+
+    if [[ -n "$cmd" ]]; then
+      _aish_save_history "$query"
+
+      # Fill placeholders if any
+      if ! _aish_fill_placeholders "$cmd"; then
+        # Cancelled during placeholder fill
+        region_highlight=("${saved_region_highlight[@]}")
+        BUFFER="$saved_buffer"
+        CURSOR="$saved_cursor"
+        zle -R
+        return
+      fi
+      cmd="$_aish_input_query"
+
+      if [[ -n "$context" ]]; then
+        context="${context}
+
+User refinement: ${query}
+Command: ${cmd}"
+      else
+        context="User request: ${query}
+Command: ${cmd}"
+      fi
+
+      # Show result with hints and stats
+      BUFFER="$cmd"
+      CURSOR=${#BUFFER}
+      local hints=$'\n  tab: refine  │  enter: accept  │  esc: cancel'
+      [[ -n "$stats" ]] && hints+="  │  ${stats}"
+      POSTDISPLAY="$hints"
+      # Highlight POSTDISPLAY area (starts after BUFFER)
+      local hint_start=${#BUFFER}
+      local hint_end=$(( hint_start + ${#hints} ))
+      region_highlight=("${saved_region_highlight[@]}" "${hint_start} ${hint_end} fg=8")
+      zle -R
+
+      # Wait for user choice - read into REPLY (no variable assignment shown)
+      zle -R
+      read -sk1
+
+      # Clear hints
+      POSTDISPLAY=""
+
+      # Handle key based on REPLY
+      if [[ "$REPLY" == $'\t' ]]; then
+        # Tab - refine
+        BUFFER=""
+        CURSOR=0
+        zle -R
+        continue
+      elif [[ "$REPLY" == $'\e' ]]; then
+        region_highlight=("${saved_region_highlight[@]}")
+        BUFFER="$saved_buffer"
+        CURSOR="$saved_cursor"
+        zle -R
+        return
+      elif [[ "$REPLY" == $'\n' || "$REPLY" == $'\r' ]]; then
+        return
+      else
+        [[ "$REPLY" == [[:print:]] ]] && BUFFER="${cmd}${REPLY}" && CURSOR=${#BUFFER}
+        return
+      fi
+    else
+      region_highlight=("${saved_region_highlight[@]}")
+      BUFFER="$saved_buffer"
+      CURSOR="$saved_cursor"
+      zle -R
+      return
+    fi
+  done
+}
+
+zle -N _aish_widget
+bindkey '^G' _aish_widget

package/dist/index.js

@@ -2,61 +2,159 @@
 
 // src/ai.ts
 import { execFile, spawn } from "child_process";
-import { readFile, unlink } from "fs/promises";
-import { tmpdir } from "os";
+import { readFile, writeFile, unlink, access, mkdir } from "fs/promises";
+import { createHash } from "crypto";
+import { tmpdir, homedir } from "os";
 import { join } from "path";
 var SYSTEM_PROMPT = `You are a CLI assistant that converts natural language into the exact shell commands to run.
 
-RESEARCH STEPS (do all of these before responding):
-1. Read the README.md (or README) file thoroughly \u2014 it often documents available commands, flags, and workflows.
-2. Read the Makefile, package.json scripts, Justfile, Taskfile.yml, docker-compose.yml, Cargo.toml, or pyproject.toml \u2014 whichever exist \u2014 to find available targets/scripts.
-3. When the user's request maps to a specific command or script, run it with --help to discover the exact flags and options available.
-4. Cross-reference what you found: use the exact flag names and syntax from --help output and documentation, not guesses.
+GUIDELINES:
+1. For standard commands (git, ls, curl, etc.), respond immediately without reading files.
+2. For project-specific commands (build, test, run scripts, etc.), ALWAYS read README.md first (if it exists), then the relevant config file:
+   - Node.js: package.json
+   - Python: pyproject.toml, setup.py, or Pipfile
+   - Rust: Cargo.toml
+   - Go: go.mod
+   - Ruby: Gemfile
+   - Make: Makefile
+   - Other: Justfile, Taskfile.yml
+3. ALWAYS prefer project scripts over direct tool invocation:
+   - Use "npm run build" not "tsup" or "tsc"
+   - Use "make test" not the underlying test command
+   - Use "cargo build" not "rustc" directly
+   This ensures correct flags, environment, and project configuration.
+4. If unsure about exact flags, provide multiple options.
 
-RESPONSE FORMAT:
-Respond with ONLY a JSON object: {"commands": ["command1", "command2"]}
-No explanation, no markdown, no code fences. Just raw JSON.
-Prefer existing scripts/targets with correct flags over raw commands.`;
+RESPONSE FORMAT \u2014 THIS IS CRITICAL:
+Your final message MUST be ONLY a JSON object. No prose, no explanation, no "Based on...", no markdown.
+Exactly this format: {"commands": ["command1"]}
+If you are unsure which command the user wants, return multiple options and the user will pick: {"commands": ["option1", "option2"]}
+For values the user hasn't specified, use <placeholders> like: git commit -m "<message>" or curl <url>. Use descriptive names inside the angle brackets.`;
+var TOOL_HINTS = [
+  { files: ["bun.lockb", "bun.lock"], hint: "Use bun (not npm/yarn/pnpm)" },
+  { files: ["pnpm-lock.yaml"], hint: "Use pnpm (not npm/yarn)" },
+  { files: ["yarn.lock"], hint: "Use yarn (not npm/pnpm)" },
+  { files: ["package-lock.json"], hint: "Use npm (not yarn/pnpm)" },
+  { files: ["Cargo.lock"], hint: "Use cargo for Rust commands" },
+  { files: ["poetry.lock"], hint: "Use poetry (not pip)" },
+  { files: ["Pipfile.lock"], hint: "Use pipenv (not pip)" },
+  { files: ["uv.lock"], hint: "Use uv (not pip/poetry)" },
+  { files: ["Gemfile.lock"], hint: "Use bundle exec for Ruby commands" },
+  { files: ["go.sum"], hint: "Use go modules" },
+  { files: ["flake.lock"], hint: "Nix flake project - use nix commands" }
+];
+async function gatherProjectContext(cwd) {
+  const hints = [];
+  for (const { files, hint } of TOOL_HINTS) {
+    for (const file of files) {
+      try {
+        await access(join(cwd, file));
+        hints.push(hint);
+        break;
+      } catch {
+      }
+    }
+  }
+  if (hints.length > 0) logVerbose(`  hints: ${hints.join(", ")}`);
+  if (hints.length === 0) return "";
+  return `
+
+Tool hints:
+- ${hints.join("\n- ")}`;
+}
 var verbose = false;
 function setVerbose(v) {
   verbose = v;
 }
-function execPromise(cmd, args, cwd) {
-  if (verbose) {
-    console.error(`\x1B[2m$ ${cmd} ${args.join(" ")}\x1B[0m`);
-    console.error(`\x1B[2m  cwd: ${cwd}\x1B[0m`);
+function tryParseJson(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed.command === "string") {
+      return [parsed.command];
+    }
+    if (Array.isArray(parsed.commands) && parsed.commands.every((c) => typeof c === "string")) {
+      return parsed.commands;
+    }
+  } catch {
   }
-  return new Promise((resolve, reject) => {
-    execFile(cmd, args, { cwd, maxBuffer: 1024 * 1024, timeout: 12e4 }, (err, stdout, stderr) => {
-      if (verbose) {
-        if (stderr) console.error(`\x1B[2mstderr: ${stderr}\x1B[0m`);
-        if (stdout) console.error(`\x1B[2mstdout: ${stdout.slice(0, 500)}\x1B[0m`);
-        if (err) console.error(`\x1B[2merror: ${err.message}\x1B[0m`);
-      }
-      if (err) reject(err);
-      else resolve({ stdout, stderr });
-    });
-  });
+  return null;
 }
-function parseCommands(raw) {
-  let cleaned = raw.trim();
-  cleaned = cleaned.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "");
-  cleaned = cleaned.trim();
-  const parsed = JSON.parse(cleaned);
-  if (!parsed.commands || !Array.isArray(parsed.commands)) {
-    throw new Error("Invalid response: missing commands array");
+function parseResponse(raw) {
+  let text = raw.trim();
+  let commands = tryParseJson(text);
+  if (commands) return { commands };
+  const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  if (fenceMatch) {
+    commands = tryParseJson(fenceMatch[1].trim());
+    if (commands) return { commands };
   }
-  if (!parsed.commands.every((c) => typeof c === "string")) {
-    throw new Error("Invalid response: commands must be strings");
+  const jsonMatch = text.match(/\{[\s\S]*"commands?"\s*:[\s\S]*\}/);
+  if (jsonMatch) {
+    commands = tryParseJson(jsonMatch[0]);
+    if (commands) return { commands };
   }
-  return parsed.commands;
+  const backtickCmds = [...text.matchAll(/`([^`]+)`/g)].map((m) => m[1].trim()).filter((c) => c.length > 2 && !c.includes("{") && !c.startsWith("//"));
+  if (backtickCmds.length > 0) return { commands: backtickCmds };
+  throw new Error("Could not parse AI response. Run with -v to debug.");
 }
-function spawnWithStdin(cmd, args, input2, cwd) {
-  if (verbose) {
-    console.error(`\x1B[2m$ echo '...' | ${cmd} ${args.join(" ")}\x1B[0m`);
-    console.error(`\x1B[2m  cwd: ${cwd}\x1B[0m`);
-    console.error(`\x1B[2m  stdin: ${input2.slice(0, 200)}...\x1B[0m`);
+var DIM = "\x1B[2m";
+var R = "\x1B[0m";
+function logVerbose(msg) {
+  if (verbose) console.error(`${DIM}${msg}${R}`);
+}
+function formatStats(wrapper) {
+  const lines = [];
+  const duration = wrapper.duration_ms;
+  const apiDuration = wrapper.duration_api_ms;
+  const turns = wrapper.num_turns;
+  const cost = wrapper.total_cost_usd;
+  const usage = wrapper.usage;
+  if (duration != null) {
+    const secs = (duration / 1e3).toFixed(1);
+    const apiSecs = apiDuration ? ` (api: ${(apiDuration / 1e3).toFixed(1)}s)` : "";
+    lines.push(`  time: ${secs}s${apiSecs}`);
+  }
+  if (turns != null) lines.push(`  turns: ${turns}`);
+  if (cost != null) lines.push(`  cost: $${cost.toFixed(4)}`);
+  if (usage) {
+    const input2 = (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+    const output = usage.output_tokens || 0;
+    lines.push(`  tokens: ${input2} in / ${output} out`);
+  }
+  return lines.join("\n");
+}
+var CACHE_DIR = join(homedir(), ".cache", "aish");
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+function cacheKey(query, context, model) {
+  return createHash("sha256").update(`${model}:${query}:${context}`).digest("hex").slice(0, 16);
+}
+async function cacheGet(key) {
+  try {
+    const filePath = join(CACHE_DIR, `${key}.json`);
+    const stat = await access(filePath).then(() => true).catch(() => false);
+    if (!stat) return null;
+    const raw = await readFile(filePath, "utf-8");
+    const entry = JSON.parse(raw);
+    if (Date.now() - entry.ts > CACHE_TTL_MS) {
+      await unlink(filePath).catch(() => {
+      });
+      return null;
+    }
+    return entry.result;
+  } catch {
+    return null;
   }
+}
+async function cacheSet(key, result) {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+    await writeFile(join(CACHE_DIR, `${key}.json`), JSON.stringify({ ts: Date.now(), result }));
+  } catch {
+  }
+}
+function spawnWithStdin(cmd, args, input2, cwd) {
+  logVerbose(`$ ${cmd} ${args.join(" ")}`);
+  logVerbose(`  cwd: ${cwd}`);
   return new Promise((resolve, reject) => {
     const child = spawn(cmd, args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
     let stdout = "";
@@ -64,10 +162,7 @@ function spawnWithStdin(cmd, args, input2, cwd) {
     child.stdout.on("data", (d) => stdout += d);
     child.stderr.on("data", (d) => stderr += d);
     child.on("close", (code) => {
-      if (verbose) {
-        if (stderr) console.error(`\x1B[2mstderr: ${stderr.slice(0, 500)}\x1B[0m`);
-        if (stdout) console.error(`\x1B[2mstdout: ${stdout.slice(0, 500)}\x1B[0m`);
-      }
+      if (verbose && stderr) logVerbose(`stderr: ${stderr.slice(0, 500)}`);
       if (code !== 0) reject(new Error(`${cmd} exited with code ${code}
 ${stderr}`));
       else resolve({ stdout, stderr });
@@ -78,48 +173,80 @@ ${stderr}`));
   });
 }
 async function queryClaude(query, cwd, model) {
-  const prompt = `${SYSTEM_PROMPT}
+  const effectiveModel = model || "sonnet";
+  const context = await gatherProjectContext(cwd);
+  const key = cacheKey(query, context, effectiveModel);
+  const cached = await cacheGet(key);
+  if (cached) {
+    logVerbose("  cache: hit");
+    return { ...cached, stats: { cached: true } };
+  }
+  const prompt = `${SYSTEM_PROMPT}${context}
 
 User request: ${query}`;
   const args = [
     "-p",
     "--output-format",
-    "json"
+    "json",
+    "--model",
+    effectiveModel,
+    "--allowedTools",
+    "Read,Glob"
   ];
-  if (model) {
-    args.push("--model", model);
-  } else {
-    args.push("--model", "sonnet");
-  }
   const { stdout } = await spawnWithStdin("claude", args, prompt, cwd);
   let text = stdout.trim();
+  let stats = {};
   try {
     const wrapper = JSON.parse(text);
+    if (verbose) {
+      logVerbose(formatStats(wrapper));
+      if (wrapper.result) logVerbose(`  result: ${wrapper.result}`);
+    }
+    stats.durationMs = wrapper.duration_ms;
+    stats.cost = wrapper.total_cost_usd;
+    if (wrapper.usage) {
+      stats.inputTokens = (wrapper.usage.input_tokens || 0) + (wrapper.usage.cache_creation_input_tokens || 0) + (wrapper.usage.cache_read_input_tokens || 0);
+      stats.outputTokens = wrapper.usage.output_tokens || 0;
+    }
     if (wrapper.result) {
       text = wrapper.result;
     }
   } catch {
+    if (verbose) logVerbose(`  raw: ${text.slice(0, 500)}`);
   }
-  return { commands: parseCommands(text) };
+  const result = parseResponse(text);
+  result.cacheKey = key;
+  result.stats = stats;
+  return result;
 }
 async function queryCodex(query, cwd, model) {
+  const startTime = Date.now();
+  const context = await gatherProjectContext(cwd);
   const resultFile = join(tmpdir(), `aish-codex-${Date.now()}.txt`);
+  const prompt = `${SYSTEM_PROMPT}${context}
+
+User request: ${query}`;
   const args = [
     "exec",
+    "--sandbox",
+    "read-only",
+    "-c",
+    'model_reasoning_effort="low"',
     "-o",
     resultFile,
-    `${SYSTEM_PROMPT}
-
-User request: ${query}`
+    "-"
+    // Read prompt from stdin
   ];
   if (model) {
     args.push("--model", model);
   }
-  await execPromise("codex", args, cwd);
+  await spawnWithStdin("codex", args, prompt, cwd);
   const text = await readFile(resultFile, "utf-8");
   await unlink(resultFile).catch(() => {
   });
-  return { commands: parseCommands(text) };
+  const result = parseResponse(text);
+  result.stats = { durationMs: Date.now() - startTime };
+  return result;
 }
 async function queryAi(provider, query, cwd, model) {
   if (provider === "codex") {
@@ -129,39 +256,75 @@ async function queryAi(provider, query, cwd, model) {
 }
 
 // src/ui.ts
+import { createInterface } from "readline";
 import { select, input } from "@inquirer/prompts";
 var CYAN = "\x1B[36m";
+var DIM2 = "\x1B[2m";
+var YELLOW = "\x1B[33m";
 var RESET = "\x1B[0m";
-async function promptEdit(cmd) {
-  const edited = await input({
-    message: "Edit command:",
-    default: cmd
+var PLACEHOLDER_RE = /<([^>]+)>/g;
+async function fillPlaceholders(cmd) {
+  const placeholders = [...cmd.matchAll(PLACEHOLDER_RE)];
+  if (placeholders.length === 0) return cmd;
+  console.log(`${DIM2}  Fill in the placeholders:${RESET}`);
+  let result = cmd;
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of placeholders) {
+    const full = match[0];
+    const name = match[1];
+    if (seen.has(full)) continue;
+    seen.add(full);
+    const value = await input({
+      message: `${YELLOW}${name}${RESET}`
+    });
+    if (!value.trim()) return null;
+    result = result.replaceAll(full, value);
+  }
+  return result;
+}
+function promptEdit(cmd) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true
+    });
+    rl.write(cmd);
+    rl.on("line", (line) => {
+      rl.close();
+      const trimmed = line.trim();
+      resolve(trimmed || null);
+    });
+    rl.on("close", () => resolve(null));
   });
-  const trimmed = edited.trim();
-  return trimmed || null;
 }
 async function promptAction(cmd) {
-  console.log(`
-  ${CYAN}${cmd}${RESET}
-`);
+  const hasPlaceholders = PLACEHOLDER_RE.test(cmd);
+  PLACEHOLDER_RE.lastIndex = 0;
   const action = await select({
     message: "Action:",
     choices: [
-      { name: "Run", value: "run" },
-      { name: "Edit", value: "edit" },
+      { name: hasPlaceholders ? "Run (fill placeholders)" : "Run", value: "run" },
+      { name: `Edit ${DIM2}(modify command before running)${RESET}`, value: "edit" },
       { name: "Cancel", value: "cancel" }
     ]
   });
-  if (action === "run") return cmd;
-  if (action === "edit") return promptEdit(cmd);
+  if (action === "run") return fillPlaceholders(cmd);
+  if (action === "edit") {
+    process.stdout.write(`${DIM2}> ${RESET}`);
+    return promptEdit(cmd);
+  }
   return null;
 }
 async function promptCommand(commands) {
   if (commands.length === 1) {
+    console.log(`
+  ${CYAN}${commands[0]}${RESET}
+`);
     return promptAction(commands[0]);
   }
   const choice = await select({
-    message: "Select a command to run:",
+    message: "Select a command:",
     choices: [
       ...commands.map((cmd) => ({
         name: `${CYAN}${cmd}${RESET}`,
@@ -171,6 +334,9 @@ async function promptCommand(commands) {
     ]
   });
   if (choice === "__cancel__") return null;
+  console.log(`
+  ${CYAN}${choice}${RESET}
+`);
   return promptAction(choice);
 }
 
@@ -190,13 +356,13 @@ function execCommand(cmd, cwd) {
 
 // src/index.ts
 var BRAILLE = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var DIM = "\x1B[2m";
+var DIM3 = "\x1B[2m";
 var RESET2 = "\x1B[0m";
 var RED = "\x1B[31m";
 function startSpinner(message) {
   let i = 0;
   const interval = setInterval(() => {
-    process.stderr.write(`\r${DIM}${BRAILLE[i++ % BRAILLE.length]} ${message}${RESET2}`);
+    process.stderr.write(`\r${DIM3}${BRAILLE[i++ % BRAILLE.length]} ${message}${RESET2}`);
   }, 80);
   return () => {
     clearInterval(interval);
@@ -209,6 +375,7 @@ function parseArgs(argv) {
   let cwd = process.cwd();
   let model = process.env.AISH_MODEL || void 0;
   let verbose2 = false;
+  let print = false;
   const queryParts = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -225,6 +392,8 @@ function parseArgs(argv) {
       model = args[++i];
     } else if (arg === "-v" || arg === "--verbose") {
       verbose2 = true;
+    } else if (arg === "--print") {
+      print = true;
     } else if (arg === "-h" || arg === "--help") {
       console.log(`Usage: aish [options] <query...>
 
@@ -232,38 +401,74 @@ Options:
   -p, --provider <claude|codex>  AI provider (default: claude, env: AISH_PROVIDER)
   -m, --model <model>            Model override (env: AISH_MODEL)
   --cwd <dir>                    Working directory
+  --print                        Output command only (for shell integration)
   -v, --verbose                  Show debug output
-  -h, --help                     Show help`);
+  -h, --help                     Show help
+
+Zsh Integration:
+  Add to .zshrc: source "$(npm root -g)/aish-cli/aish.plugin.zsh"
+  Then press Ctrl+G to activate AI mode`);
       process.exit(0);
     } else {
       queryParts.push(arg);
     }
   }
-  return { query: queryParts.join(" "), provider, cwd, model, verbose: verbose2 };
+  return { query: queryParts.join(" "), provider, cwd, model, verbose: verbose2, print };
 }
 async function main() {
-  const { query, provider, cwd, model, verbose: verbose2 } = parseArgs(process.argv);
+  const { query, provider, cwd, model, verbose: verbose2, print } = parseArgs(process.argv);
   setVerbose(verbose2);
   if (!query) {
     console.error(`${RED}Usage: aish <query>${RESET2}`);
     process.exit(1);
   }
-  const stopSpinner = verbose2 ? () => {
+  const stopSpinner = verbose2 || print ? () => {
   } : startSpinner("Thinking...");
   let commands;
+  let resultCacheKey;
+  let stats;
   try {
     const result = await queryAi(provider, query, cwd, model);
     commands = result.commands;
+    resultCacheKey = result.cacheKey;
+    stats = result.stats;
   } catch (err) {
     stopSpinner();
+    if (print) {
+      process.exit(1);
+    }
     console.error(`${RED}Error: ${err.message}${RESET2}`);
     process.exit(1);
   }
   stopSpinner();
+  if (stats) {
+    const parts = [];
+    if (stats.cached) {
+      parts.push("cached");
+    } else {
+      if (stats.durationMs) parts.push(`${(stats.durationMs / 1e3).toFixed(1)}s`);
+      if (stats.inputTokens || stats.outputTokens) {
+        parts.push(`${stats.inputTokens || 0}\u2192${stats.outputTokens || 0} tok`);
+      }
+      if (stats.cost) parts.push(`$${stats.cost.toFixed(4)}`);
+    }
+    if (parts.length > 0) {
+      const output = print ? process.stderr : process.stdout;
+      output.write(`${DIM3}  ${parts.join(" \xB7 ")}${RESET2}
+`);
+    }
+  }
   if (commands.length === 0) {
+    if (print) {
+      process.exit(1);
+    }
     console.error(`${RED}No commands suggested.${RESET2}`);
     process.exit(1);
   }
+  if (print) {
+    console.log(commands[0]);
+    process.exit(0);
+  }
   let chosen;
   try {
     chosen = await promptCommand(commands);
@@ -274,6 +479,9 @@ async function main() {
   if (!chosen) {
     process.exit(0);
   }
+  if (resultCacheKey) {
+    await cacheSet(resultCacheKey, { commands });
+  }
   const exitCode = await execCommand(chosen, cwd);
   process.exit(exitCode);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aish-cli",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "AI Shell - convert natural language to bash commands using Claude or Codex",
   "type": "module",
   "license": "MIT",
@@ -8,11 +8,22 @@
     "type": "git",
     "url": "https://github.com/janicduplessis/aish.git"
   },
-  "keywords": ["ai", "shell", "cli", "claude", "codex", "bash", "natural-language"],
+  "keywords": [
+    "ai",
+    "shell",
+    "cli",
+    "claude",
+    "codex",
+    "bash",
+    "natural-language"
+  ],
   "bin": {
     "aish": "./dist/index.js"
   },
-  "files": ["dist"],
+  "files": [
+    "dist",
+    "aish.plugin.zsh"
+  ],
   "scripts": {
     "build": "tsup",
     "dev": "tsx src/index.ts",