@atharvaspatil5/aish 1.0.1

package/README.md

@@ -0,0 +1,70 @@
+# AI.sh
+
+AI.sh is a CLI tool that converts natural language into safe shell commands.
+
+## Usage
+
+```bash
+ai "list files"
+ai "delete node_modules"
+ai "find files larger than 100MB"
+```
+
+## Options
+
+```bash
+-y, --yes    skip confirmation prompt
+```
+
+## How it works
+
+1. Takes user input from CLI
+2. Sends it to Groq (LLM)
+3. Converts it into a shell command
+4. Validates the command for safety
+5. Asks for confirmation (optional)
+6. Executes the command
+
+## Example
+
+```bash
+ai "list all files"
+# → ls
+
+ai "delete everything"
+# → rm -i *
+```
+
+## Safety
+
+* Blocks critical system-level commands
+* Warns on risky operations (like file deletion)
+* Requires confirmation before execution
+
+## Setup
+
+```bash
+npm install
+npm link
+```
+
+Create a `.env` file:
+
+```env
+GROQ_API_KEY=your_api_key
+```
+
+## Structure
+
+```
+bin/        CLI entry
+src/        core logic
+  llm.js
+  validator.js
+  executor.js
+  index.js
+```
+
+## Notes
+
+This is a local CLI tool. Use carefully when executing destructive commands.

package/bin/ai.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import chalk from "chalk";
+import { getCommand } from "../src/llm.js";
+import { askConfirmation, runCommand } from "../src/executor.js";
+
+const program = new Command();
+
+program
+  .name("ai")
+  .description("AI-powered shell assistant")
+  .argument("<query>", "What you want to do")
+  .option("-y, --yes", "Skip confirmation prompt")
+  .action(async (query, options) => {
+    const result = await getCommand(query);
+
+    let coloredCommand;
+    if (result.risk_level === "danger") {
+      coloredCommand = chalk.red(result.command);
+    } else if (result.risk_level === "warning") {
+      coloredCommand = chalk.yellow(result.command);
+    } else {
+      coloredCommand = chalk.green(result.command);
+    }
+
+    console.log(coloredCommand);
+
+    let confirm = true;
+
+    if (!options.yes || result.risk_level === "danger") {
+      confirm = await askConfirmation("Run this? (y/n) ");
+    }
+
+    if (!confirm) {
+      console.log(chalk.blue("Command execution cancelled."));
+      return;
+    }
+
+    try {
+      const output = await runCommand(result.command);
+      console.log(output);
+    } catch (error) {
+      console.error(chalk.red("Error: "));
+      console.error(chalk.red(error.message));
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@atharvaspatil5/aish",
+  "version": "1.0.1",
+  "description": "AI-powered CLI that converts natural language to shell commands",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "athPATIL247",
+  "license": "ISC",
+  "bin": {
+    "ai": "./bin/ai.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "dotenv": "^17.4.0",
+    "groq-sdk": "^1.1.2"
+  }
+}

package/src/executor.js

@@ -0,0 +1,28 @@
+import { exec } from "child_process";
+import readline from "readline";
+
+export function askConfirmation(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+
+export function runCommand(command) {
+  return new Promise((resolve, reject) => {
+    exec(command, (error, stdout, stderr) => {
+      if (error) {
+        reject(stderr || error.message);
+      } else {
+        resolve(stdout);
+      }
+    });
+  });
+}

package/src/index.js

@@ -0,0 +1 @@
+// Entry point is bin/ai.js

package/src/llm.js

@@ -0,0 +1,63 @@
+import Groq from "groq-sdk";
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const envPath = join(__dirname, '..', '.env');
+const envContent = readFileSync(envPath, 'utf8');
+const envLines = envContent.split('\n');
+for (const line of envLines) {
+    const [key, ...valueParts] = line.split('=');
+    if (key && valueParts.length) {
+        process.env[key.trim()] = valueParts.join('=').trim();
+    }
+}
+
+const groq = new Groq({
+    apiKey: process.env.GROQ_API_KEY,
+});
+
+export async function getCommand(query){
+    const response = await groq.chat.completions.create({
+        model: "llama-3.1-8b-instant",
+        messages: [
+            {
+                role: "system",
+                content: `You are a Linux shell expert. Convert user instructions into a single shell command and assess its risk level.
+
+Output ONLY a JSON object with exactly these fields:
+- command: the shell command (string)
+- risk_level: "safe", "warning", or "danger" (string)
+
+Do not output any other text, explanations, code blocks, or notes. Just the raw JSON.`,
+            },
+            {
+                role: "user",
+                content: query,
+            },
+        ],
+    });
+
+    const content = response.choices[0].message.content.trim();
+    // Remove markdown code blocks if present
+    let jsonString = content;
+    if (jsonString.startsWith('```json')) {
+        jsonString = jsonString.replace(/^```json\s*/, '').replace(/\s*```$/, '');
+    } else if (jsonString.startsWith('```')) {
+        jsonString = jsonString.replace(/^```\s*/, '').replace(/\s*```$/, '');
+    }
+    try {
+        const result = JSON.parse(jsonString);
+        return result;
+    } catch (e) {
+        // Fallback: assume safe if parsing fails
+        return {
+            command: content,
+            risk_level: "safe",
+            reason: "Unable to assess risk"
+        };
+    }
+}