aish-cli 1.0.0

package/README.md

@@ -0,0 +1,67 @@
+# aish
+
+AI Shell - convert natural language to bash commands.
+
+Describe what you want to do and `aish` translates it into the right shell command using [Claude Code](https://docs.anthropic.com/en/docs/claude-code) or [Codex](https://github.com/openai/codex) CLI. It reads your project files (Makefile, package.json, README, etc.) and checks `--help` output to get the exact flags right.
+
+## Install
+
+```bash
+npm install -g aish-cli
+```
+
+Requires [Claude Code](https://docs.anthropic.com/en/docs/claude-code) (`claude` CLI) or [Codex](https://github.com/openai/codex) installed and authenticated.
+
+## Usage
+
+```bash
+aish <natural language query>
+```
+
+### Examples
+
+```bash
+# Simple commands
+aish list files
+
+# Project-aware - reads your Makefile/package.json to find the right command
+aish start the dev server
+aish package ios app in debug, skip setup
+
+# Multi-step tasks
+aish create a new branch, commit everything, and push
+```
+
+`aish` will suggest a command, then let you **Run**, **Edit**, or **Cancel** before executing anything.
+
+### Options
+
+```
+-p, --provider <claude|codex>  AI provider (default: claude)
+-m, --model <model>            Model override
+--cwd <dir>                    Working directory
+-v, --verbose                  Show debug output
+-h, --help                     Show help
+```
+
+### Environment Variables
+
+| Variable | Description | Default |
+|---|---|---|
+| `AISH_PROVIDER` | AI provider (`claude` or `codex`) | `claude` |
+| `AISH_MODEL` | Model to use | `sonnet` |
+
+Flags take precedence over environment variables.
+
+## How It Works
+
+1. You type a natural language query
+2. `aish` invokes the AI CLI in your project directory
+3. The AI reads your project files (README, Makefile, package.json, etc.) and runs `--help` on relevant commands to discover exact flags
+4. Returns one or more suggested commands
+5. You choose to **Run**, **Edit**, or **Cancel**
+6. On Run/Edit the command executes with your shell, inheriting stdio
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+
+// src/ai.ts
+import { execFile, spawn } from "child_process";
+import { readFile, unlink } from "fs/promises";
+import { tmpdir } 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.
+
+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.`;
+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`);
+  }
+  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 });
+    });
+  });
+}
+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");
+  }
+  if (!parsed.commands.every((c) => typeof c === "string")) {
+    throw new Error("Invalid response: commands must be strings");
+  }
+  return parsed.commands;
+}
+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`);
+  }
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    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 (code !== 0) reject(new Error(`${cmd} exited with code ${code}
+${stderr}`));
+      else resolve({ stdout, stderr });
+    });
+    child.on("error", reject);
+    child.stdin.write(input2);
+    child.stdin.end();
+  });
+}
+async function queryClaude(query, cwd, model) {
+  const prompt = `${SYSTEM_PROMPT}
+
+User request: ${query}`;
+  const args = [
+    "-p",
+    "--output-format",
+    "json"
+  ];
+  if (model) {
+    args.push("--model", model);
+  } else {
+    args.push("--model", "sonnet");
+  }
+  const { stdout } = await spawnWithStdin("claude", args, prompt, cwd);
+  let text = stdout.trim();
+  try {
+    const wrapper = JSON.parse(text);
+    if (wrapper.result) {
+      text = wrapper.result;
+    }
+  } catch {
+  }
+  return { commands: parseCommands(text) };
+}
+async function queryCodex(query, cwd, model) {
+  const resultFile = join(tmpdir(), `aish-codex-${Date.now()}.txt`);
+  const args = [
+    "exec",
+    "-o",
+    resultFile,
+    `${SYSTEM_PROMPT}
+
+User request: ${query}`
+  ];
+  if (model) {
+    args.push("--model", model);
+  }
+  await execPromise("codex", args, cwd);
+  const text = await readFile(resultFile, "utf-8");
+  await unlink(resultFile).catch(() => {
+  });
+  return { commands: parseCommands(text) };
+}
+async function queryAi(provider, query, cwd, model) {
+  if (provider === "codex") {
+    return queryCodex(query, cwd, model);
+  }
+  return queryClaude(query, cwd, model);
+}
+
+// src/ui.ts
+import { select, input } from "@inquirer/prompts";
+var CYAN = "\x1B[36m";
+var RESET = "\x1B[0m";
+async function promptEdit(cmd) {
+  const edited = await input({
+    message: "Edit command:",
+    default: cmd
+  });
+  const trimmed = edited.trim();
+  return trimmed || null;
+}
+async function promptAction(cmd) {
+  console.log(`
+  ${CYAN}${cmd}${RESET}
+`);
+  const action = await select({
+    message: "Action:",
+    choices: [
+      { name: "Run", value: "run" },
+      { name: "Edit", value: "edit" },
+      { name: "Cancel", value: "cancel" }
+    ]
+  });
+  if (action === "run") return cmd;
+  if (action === "edit") return promptEdit(cmd);
+  return null;
+}
+async function promptCommand(commands) {
+  if (commands.length === 1) {
+    return promptAction(commands[0]);
+  }
+  const choice = await select({
+    message: "Select a command to run:",
+    choices: [
+      ...commands.map((cmd) => ({
+        name: `${CYAN}${cmd}${RESET}`,
+        value: cmd
+      })),
+      { name: "Cancel", value: "__cancel__" }
+    ]
+  });
+  if (choice === "__cancel__") return null;
+  return promptAction(choice);
+}
+
+// src/exec.ts
+import { spawn as spawn2 } from "child_process";
+function execCommand(cmd, cwd) {
+  return new Promise((resolve) => {
+    const shell = process.env.SHELL || "/bin/bash";
+    const child = spawn2(shell, ["-c", cmd], {
+      stdio: "inherit",
+      cwd
+    });
+    child.on("close", (code) => resolve(code ?? 1));
+    child.on("error", () => resolve(1));
+  });
+}
+
+// src/index.ts
+var BRAILLE = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var DIM = "\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}`);
+  }, 80);
+  return () => {
+    clearInterval(interval);
+    process.stderr.write("\r\x1B[K");
+  };
+}
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let provider = process.env.AISH_PROVIDER || "claude";
+  let cwd = process.cwd();
+  let model = process.env.AISH_MODEL || void 0;
+  let verbose2 = false;
+  const queryParts = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-p" || arg === "--provider") {
+      const val = args[++i];
+      if (val !== "claude" && val !== "codex") {
+        console.error(`${RED}Invalid provider: ${val}. Use "claude" or "codex".${RESET2}`);
+        process.exit(1);
+      }
+      provider = val;
+    } else if (arg === "--cwd") {
+      cwd = args[++i];
+    } else if (arg === "-m" || arg === "--model") {
+      model = args[++i];
+    } else if (arg === "-v" || arg === "--verbose") {
+      verbose2 = true;
+    } else if (arg === "-h" || arg === "--help") {
+      console.log(`Usage: aish [options] <query...>
+
+Options:
+  -p, --provider <claude|codex>  AI provider (default: claude, env: AISH_PROVIDER)
+  -m, --model <model>            Model override (env: AISH_MODEL)
+  --cwd <dir>                    Working directory
+  -v, --verbose                  Show debug output
+  -h, --help                     Show help`);
+      process.exit(0);
+    } else {
+      queryParts.push(arg);
+    }
+  }
+  return { query: queryParts.join(" "), provider, cwd, model, verbose: verbose2 };
+}
+async function main() {
+  const { query, provider, cwd, model, verbose: verbose2 } = parseArgs(process.argv);
+  setVerbose(verbose2);
+  if (!query) {
+    console.error(`${RED}Usage: aish <query>${RESET2}`);
+    process.exit(1);
+  }
+  const stopSpinner = verbose2 ? () => {
+  } : startSpinner("Thinking...");
+  let commands;
+  try {
+    const result = await queryAi(provider, query, cwd, model);
+    commands = result.commands;
+  } catch (err) {
+    stopSpinner();
+    console.error(`${RED}Error: ${err.message}${RESET2}`);
+    process.exit(1);
+  }
+  stopSpinner();
+  if (commands.length === 0) {
+    console.error(`${RED}No commands suggested.${RESET2}`);
+    process.exit(1);
+  }
+  let chosen;
+  try {
+    chosen = await promptCommand(commands);
+  } catch {
+    console.log();
+    process.exit(130);
+  }
+  if (!chosen) {
+    process.exit(0);
+  }
+  const exitCode = await execCommand(chosen, cwd);
+  process.exit(exitCode);
+}
+main();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "aish-cli",
+  "version": "1.0.0",
+  "description": "AI Shell - convert natural language to bash commands using Claude or Codex",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/janicduplessis/aish.git"
+  },
+  "keywords": ["ai", "shell", "cli", "claude", "codex", "bash", "natural-language"],
+  "bin": {
+    "aish": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  }
+}