shellsia 1.0.1

package/src/llm.ts

@@ -0,0 +1,133 @@
+import Groq from 'groq-sdk';
+import OpenAI from 'openai';
+import { getConfig } from './config';
+import { SystemContext } from './context';
+import { buildSystemPrompt, buildUserPrompt } from './prompt';
+
+export interface LLMResponse {
+    command: string;
+    explanation: string;
+    dangerous: boolean;
+    alternatives: string[];
+}
+
+function parseResponse(raw: string): LLMResponse {
+    // Try to extract JSON from the response, handling potential markdown code fences
+    let jsonStr = raw.trim();
+
+    // Remove markdown code fences if present
+    const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (jsonMatch) {
+        jsonStr = jsonMatch[1].trim();
+    }
+
+    // Try to find a JSON object in the response
+    const objectMatch = jsonStr.match(/\{[\s\S]*\}/);
+    if (objectMatch) {
+        jsonStr = objectMatch[0];
+    }
+
+    try {
+        const parsed = JSON.parse(jsonStr);
+        return {
+            command: parsed.command || '',
+            explanation: parsed.explanation || 'No explanation provided',
+            dangerous: Boolean(parsed.dangerous),
+            alternatives: Array.isArray(parsed.alternatives) ? parsed.alternatives : [],
+        };
+    } catch {
+        throw new Error(
+            `Failed to parse LLM response as JSON.\nRaw response:\n${raw}`
+        );
+    }
+}
+
+async function callGroq(
+    query: string,
+    context: SystemContext,
+    apiKey: string
+): Promise<LLMResponse> {
+    const groq = new Groq({ apiKey });
+
+    const completion = await groq.chat.completions.create({
+        model: 'llama-3.3-70b-versatile',
+        messages: [
+            { role: 'system', content: buildSystemPrompt(context) },
+            { role: 'user', content: buildUserPrompt(query) },
+        ],
+        temperature: 0.1,
+        max_tokens: 512,
+        response_format: { type: 'json_object' },
+    });
+
+    const content = completion.choices[0]?.message?.content;
+    if (!content) {
+        throw new Error('No response received from Groq');
+    }
+
+    return parseResponse(content);
+}
+
+async function callOpenAI(
+    query: string,
+    context: SystemContext,
+    apiKey: string
+): Promise<LLMResponse> {
+    const openai = new OpenAI({ apiKey });
+
+    const completion = await openai.chat.completions.create({
+        model: 'gpt-4o-mini',
+        messages: [
+            { role: 'system', content: buildSystemPrompt(context) },
+            { role: 'user', content: buildUserPrompt(query) },
+        ],
+        temperature: 0.1,
+        max_tokens: 512,
+        response_format: { type: 'json_object' },
+    });
+
+    const content = completion.choices[0]?.message?.content;
+    if (!content) {
+        throw new Error('No response received from OpenAI');
+    }
+
+    return parseResponse(content);
+}
+
+export async function queryLLM(
+    query: string,
+    context: SystemContext
+): Promise<LLMResponse> {
+    const config = getConfig();
+    const provider = config.defaultProvider;
+
+    if (provider === 'groq' && config.groqApiKey) {
+        try {
+            return await callGroq(query, context, config.groqApiKey);
+        } catch (err) {
+            // If Groq fails and we have an OpenAI key, fall back
+            if (config.openaiApiKey) {
+                console.warn('Groq failed, falling back to OpenAI...');
+                return await callOpenAI(query, context, config.openaiApiKey);
+            }
+            throw err;
+        }
+    }
+
+    if (provider === 'openai' && config.openaiApiKey) {
+        return await callOpenAI(query, context, config.openaiApiKey);
+    }
+
+    // Auto-detect available provider
+    if (config.groqApiKey) {
+        return await callGroq(query, context, config.groqApiKey);
+    }
+
+    if (config.openaiApiKey) {
+        return await callOpenAI(query, context, config.openaiApiKey);
+    }
+
+    throw new Error(
+        'No API key configured. Run "s --setup" to configure your API keys.'
+    );
+}

package/src/prompt.ts

@@ -0,0 +1,48 @@
+import { SystemContext } from './context';
+
+export function buildSystemPrompt(context: SystemContext): string {
+  const osName = {
+    darwin: 'macOS',
+    linux: 'Linux',
+    win32: 'Windows',
+  }[context.os] || context.os;
+
+  return `You are Shellsia, an expert shell command assistant. Your job is to translate natural language requests into precise, working shell commands.
+
+ENVIRONMENT:
+- Operating System: ${osName} (${context.os})
+- Shell: ${context.shell}
+- Current Directory: ${context.cwd}
+- Home Directory: ${context.homeDir}
+- User: ${context.username}
+- Architecture: ${context.arch}
+
+RULES:
+1. Return ONLY a valid JSON object — no markdown, no code fences, no extra text.
+2. Never use sudo unless the user explicitly asks for it.
+3. Prefer readable, well-structured commands over clever one-liners.
+4. Use commands compatible with the detected OS and shell.
+5. If a command could be destructive (deletes files, overwrites data, modifies system config), mark "dangerous" as true.
+6. Provide 1-2 alternative commands when applicable (simpler or safer variants).
+7. The explanation should be one clear sentence describing what the command does.
+
+RESPONSE FORMAT (strict JSON):
+{
+  "command": "the exact shell command to run",
+  "explanation": "one sentence explaining what this command does",
+  "dangerous": false,
+  "alternatives": ["alternative command 1", "alternative command 2"]
+}
+
+If you cannot produce a valid command, return:
+{
+  "command": "",
+  "explanation": "I'm unable to generate a command for this request because...",
+  "dangerous": false,
+  "alternatives": []
+}`;
+}
+
+export function buildUserPrompt(query: string): string {
+  return `Convert this to a shell command: "${query}"`;
+}

package/src/renderer.ts

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+import { LLMResponse } from './llm';
+
+function pad(str: string, width: number): string {
+    const visible = str.replace(/\u001b\[[0-9;]*m/g, '');
+    const padding = Math.max(0, width - visible.length);
+    return str + ' '.repeat(padding);
+}
+
+export function renderResponse(response: LLMResponse): void {
+    const { command, explanation, dangerous, alternatives } = response;
+
+    if (!command) {
+        console.log(chalk.yellow('\n⚠  Could not generate a command.'));
+        console.log(chalk.gray(`   ${explanation}\n`));
+        return;
+    }
+
+    const boxWidth = Math.max(command.length + 4, 44);
+    const innerWidth = boxWidth - 4;
+
+    // Command box
+    console.log('');
+    console.log(chalk.cyan(`  ╭─ Command ${'─'.repeat(Math.max(0, boxWidth - 13))}╮`));
+    console.log(chalk.cyan('  │  ') + chalk.bold.white(pad(command, innerWidth)) + chalk.cyan('│'));
+    console.log(chalk.cyan(`  ╰${'─'.repeat(boxWidth - 2)}╯`));
+
+    // Explanation
+    console.log('');
+    console.log(chalk.gray('  Explains  ') + chalk.white(explanation));
+
+    // Dangerous warning
+    if (dangerous) {
+        console.log('');
+        console.log(chalk.red.bold('  [!] Warning: this command modifies files'));
+    }
+
+    // Sudo warning
+    if (command.toLowerCase().includes('sudo')) {
+        console.log('');
+        console.log(chalk.yellow.bold('  [⚡] This command uses sudo — elevated privileges required'));
+    }
+
+    // Alternatives
+    if (alternatives.length > 0) {
+        console.log('');
+        console.log(chalk.gray('  Alternatives:'));
+        for (const alt of alternatives) {
+            console.log(chalk.gray('    • ') + chalk.white(alt));
+        }
+    }
+
+    console.log('');
+}
+
+export function renderRunning(command: string): void {
+    console.log(chalk.cyan.bold('\n  ▶ Running: ') + chalk.white(command));
+    console.log(chalk.gray('  ' + '─'.repeat(50)));
+}
+
+export function renderSuccess(): void {
+    console.log(chalk.gray('  ' + '─'.repeat(50)));
+    console.log(chalk.green.bold('  ✓ Command finished successfully\n'));
+}
+
+export function renderError(error: string): void {
+    console.log(chalk.gray('  ' + '─'.repeat(50)));
+    console.log(chalk.red.bold('  ✗ Command failed: ') + chalk.red(error) + '\n');
+}
+
+export function renderCopied(): void {
+    console.log(chalk.green.bold('  📋 Copied to clipboard!\n'));
+}
+
+export function renderCancelled(): void {
+    console.log(chalk.gray('  Cancelled.\n'));
+}

package/src/runner.ts

@@ -0,0 +1,97 @@
+import execa from 'execa';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { getConfig } from './config';
+import { renderRunning, renderSuccess, renderError } from './renderer';
+
+async function confirmDangerousCommand(command: string): Promise<boolean> {
+    console.log(chalk.red.bold('\n  ⚠️  DANGER: This command may modify or delete files!'));
+    console.log(chalk.red(`  Command: ${command}\n`));
+
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: chalk.red.bold('Are you absolutely sure you want to run this?'),
+            default: false,
+        },
+    ]);
+
+    return confirm;
+}
+
+async function confirmRmRf(command: string): Promise<boolean> {
+    console.log(chalk.bgRed.white.bold('\n  🚨 CRITICAL: This command uses rm -rf!'));
+    console.log(chalk.red(`  Command: ${command}\n`));
+
+    const { firstConfirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'firstConfirm',
+            message: chalk.red.bold('This will PERMANENTLY delete files. Continue?'),
+            default: false,
+        },
+    ]);
+
+    if (!firstConfirm) return false;
+
+    const { secondConfirm } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'secondConfirm',
+            message: chalk.red.bold('Type "yes" to confirm deletion:'),
+        },
+    ]);
+
+    return secondConfirm.toLowerCase() === 'yes';
+}
+
+export async function runCommand(
+    command: string,
+    dangerous: boolean
+): Promise<void> {
+    const config = getConfig();
+
+    // Safety checks for dangerous commands
+    if (dangerous && config.confirmBeforeRun) {
+        // Extra check for rm -rf
+        if (command.includes('rm -rf') || command.includes('rm --recursive --force')) {
+            const confirmed = await confirmRmRf(command);
+            if (!confirmed) {
+                console.log(chalk.gray('  Aborted.\n'));
+                return;
+            }
+        } else {
+            const confirmed = await confirmDangerousCommand(command);
+            if (!confirmed) {
+                console.log(chalk.gray('  Aborted.\n'));
+                return;
+            }
+        }
+    }
+
+    // Sudo warning
+    if (command.includes('sudo')) {
+        console.log(chalk.yellow('\n  ⚡ Running with elevated privileges (sudo)...'));
+    }
+
+    renderRunning(command);
+
+    try {
+        const subprocess = execa(command, {
+            shell: true,
+            stdio: 'inherit',
+            cwd: process.cwd(),
+        });
+
+        await subprocess;
+        renderSuccess();
+    } catch (err: unknown) {
+        const error = err as { message?: string; exitCode?: number };
+        const message = error.exitCode
+            ? `Exit code ${error.exitCode}`
+            : error.message || 'Unknown error';
+        renderError(message);
+        process.exitCode = 1;
+    }
+}