askimo 1.0.0 → 1.2.0

package/README.md

@@ -1,57 +1,71 @@
+  <p align="center">
+    <img width="400" height="400" alt="Askimo" 
+  src="https://github.com/user-attachments/assets/cbf2ab5d-5a07-45a2-9109-6a7bc22ea878" />
+  </p>
+
 # Askimo
 
-A CLI tool for communicating with AI providers (Perplexity, OpenAI, Anthropic).
+A CLI tool for communicating with AI providers.
+
+**Supported providers:** Perplexity · OpenAI · Anthropic · xAI (Grok)
+
+---
 
-## Installation
+## 📦 Installation
 
 ```bash
 npm install -g askimo
 ```
 
-## Configuration
+## ⚙️ Configuration
 
 Create a config file at `~/.askimo/config`:
 
-```
+```bash
 # API Keys (at least one required)
 PERPLEXITY_API_KEY=your-perplexity-key
 OPENAI_API_KEY=your-openai-key
 ANTHROPIC_API_KEY=your-anthropic-key
+XAI_API_KEY=your-xai-key
 
 # Optional settings
 DEFAULT_PROVIDER=perplexity
 PERPLEXITY_MODEL=sonar
 OPENAI_MODEL=gpt-4o
 ANTHROPIC_MODEL=claude-sonnet-4-20250514
+XAI_MODEL=grok-4
 ```
 
-## Usage
+---
 
-### Ask a single question
+## 🚀 Usage
+
+### Quick question
 
 ```bash
 askimo "What is the capital of France?"
 ```
 
-The `ask` command is the default, so you can omit it:
+### Choose a provider
 
-```bash
-askimo ask "What is the capital of France?"
-```
-
-### Provider flags
+| Flag | Provider             |
+|------|----------------------|
+| `-p` | Perplexity (default) |
+| `-o` | OpenAI               |
+| `-a` | Anthropic            |
+| `-x` | xAI (Grok)           |
 
 ```bash
-askimo "question" -p    # Use Perplexity (default)
-askimo "question" -o    # Use OpenAI
-askimo "question" -a    # Use Anthropic
+askimo "explain quantum computing" -o    # Use OpenAI
+askimo "write a haiku" -a                # Use Anthropic
+askimo "what's happening today?" -x      # Use xAI Grok
 ```
 
 ### Continue a conversation
 
 ```bash
-askimo "follow up question" -c 1    # Continue last conversation
-askimo "follow up question" -c 2    # Continue second-to-last
+askimo "tell me more" -c 1     # Continue last conversation
+askimo "go deeper" -c 2        # Continue second-to-last
 ```
 
 ### JSON output
@@ -60,36 +74,55 @@ askimo "follow up question" -c 2    # Continue second-to-last
 askimo "question" --json
 ```
 
-Returns structured JSON with provider, model, question, response, and sources (for Perplexity).
+### Pipe content
+
+```bash
+cat code.js | askimo "explain this code"
+echo "hello world" | askimo "translate to French"
+```
+
+### Read from file
+
+```bash
+askimo -f code.js "what does this do"
+askimo -f error.log "find the bug"
+```
 
 ### Interactive chat
 
 ```bash
-askimo chat
-askimo chat -o              # Chat with OpenAI
-askimo chat -c 1            # Continue last conversation
+askimo chat                # Start new chat
+askimo chat -o             # Chat with OpenAI
+askimo chat -x             # Chat with xAI Grok
+askimo chat -c 1           # Continue last conversation
 ```
 
-Type `exit` or press `Ctrl+C` to quit.
+Type `exit` or `Ctrl+C` to quit.
 
-### List available models
+### List models
 
 ```bash
-askimo models               # List all providers
-askimo models -p            # Perplexity only
-askimo models -o            # OpenAI only
-askimo models -a            # Anthropic only
+askimo models              # All providers
+askimo models -p           # Perplexity only
+askimo models -x           # xAI only
 ```
 
-## Features
+---
+
+## ✨ Features
 
-- Streaming responses
-- Conversation history (saved to `~/.askimo/conversations/`)
-- Source citations (Perplexity)
-- Multiple AI providers
-- Configurable default models
+| Feature        | Description                                       |
+|----------------|---------------------------------------------------|
+| Streaming      | Real-time response output                         |
+| Piping         | Pipe content via stdin                            |
+| File input     | Read content from files with `-f`                 |
+| Citations      | Source links with Perplexity                      |
+| History        | Conversations saved to `~/.askimo/conversations/` |
+| Multi-provider | Switch between AI providers easily                |
 
-## Development
+---
+
+## 🛠️ Development
 
 ```bash
 npm install
@@ -97,6 +130,8 @@ npm test
 npm run lint
 ```
 
-## License
+---
+
+## 📄 License
 
 Apache-2.0

package/index.mjs

@@ -4,6 +4,7 @@ import { Command } from 'commander'
 import { startChat } from './lib/chat.mjs'
 import { ensureDirectories, loadConfig } from './lib/config.mjs'
 import { createConversation, loadConversation, saveConversation } from './lib/conversation.mjs'
+import { buildMessage, readFile, readStdin } from './lib/input.mjs'
 import { DEFAULT_MODELS, determineProvider, getProvider, listModels } from './lib/providers.mjs'
 import { generateResponse, outputJson, streamResponse } from './lib/stream.mjs'
 import pkg from './package.json' with { type: 'json' }
@@ -15,14 +16,32 @@ program.name('askimo').description('CLI tool for communicating with AI providers
 program
   .command('ask', { isDefault: true })
   .description('Ask a single question')
-  .argument('<question>', 'The question to ask')
+  .argument('[question]', 'The question to ask (can also pipe content via stdin)')
   .option('-p, --perplexity', 'Use Perplexity AI (default)')
   .option('-o, --openai', 'Use OpenAI')
   .option('-a, --anthropic', 'Use Anthropic Claude')
+  .option('-x, --xai', 'Use xAI Grok')
   .option('-j, --json', 'Output as JSON instead of streaming')
   .option('-c, --continue <n>', 'Continue conversation N (1=last, 2=second-to-last)', Number.parseInt)
+  .option('-f, --file <path>', 'Read content from file')
   .action(async (question, options) => {
     try {
+      const stdinContent = await readStdin()
+      const fileContent = options.file ? await readFile(options.file) : null
+
+      if (stdinContent && options.file) {
+        console.error('Error: Cannot use both piped input and --file flag')
+        process.exit(1)
+      }
+
+      const content = stdinContent || fileContent
+      const message = buildMessage(question, content)
+
+      if (!message) {
+        console.error('Error: No question provided. Use: askimo "question" or pipe content')
+        process.exit(1)
+      }
+
       const config = await loadConfig()
       await ensureDirectories()
 
@@ -46,22 +65,22 @@ program
 
       conversation.messages.push({
         role: 'user',
-        content: question
+        content: message
       })
 
       let responseText
 
       if (options.json) {
-        const { text, sources } = await generateResponse(model, conversation.messages)
+        const { text, sources, duration } = await generateResponse(model, conversation.messages)
         responseText = text
         conversation.messages.push({
           role: 'assistant',
           content: responseText
         })
         await saveConversation(conversation, existingPath)
-        outputJson(conversation, responseText, sources)
+        outputJson(conversation, responseText, sources, duration)
       } else {
-        responseText = await streamResponse(model, conversation.messages)
+        responseText = await streamResponse(model, conversation.messages, modelName)
         conversation.messages.push({
           role: 'assistant',
           content: responseText
@@ -80,6 +99,7 @@ program
   .option('-p, --perplexity', 'Use Perplexity AI (default)')
   .option('-o, --openai', 'Use OpenAI')
   .option('-a, --anthropic', 'Use Anthropic Claude')
+  .option('-x, --xai', 'Use xAI Grok')
   .option('-c, --continue <n>', 'Continue conversation N (1=last, 2=second-to-last)', Number.parseInt)
   .action(async (options) => {
     try {
@@ -102,6 +122,7 @@ program
   .option('-p, --perplexity', 'Show only Perplexity models')
   .option('-o, --openai', 'Show only OpenAI models')
   .option('-a, --anthropic', 'Show only Anthropic models')
+  .option('-x, --xai', 'Show only xAI models')
   .action(async (options) => {
     try {
       const config = await loadConfig()
@@ -110,8 +131,9 @@ program
       if (options.perplexity) providers.push('perplexity')
       if (options.openai) providers.push('openai')
       if (options.anthropic) providers.push('anthropic')
+      if (options.xai) providers.push('xai')
 
-      const toShow = providers.length === 0 ? ['perplexity', 'openai', 'anthropic'] : providers
+      const toShow = providers.length === 0 ? ['perplexity', 'openai', 'anthropic', 'xai'] : providers
 
       const results = await Promise.all(
         toShow.map(async (provider) => ({

package/lib/chat.mjs

@@ -42,7 +42,7 @@ async function startChat(model, providerName, modelName, continueN = null) {
     })
 
     console.log('')
-    const responseText = await streamResponse(model, conversation.messages)
+    const responseText = await streamResponse(model, conversation.messages, modelName)
 
     conversation.messages.push({
       role: 'assistant',

package/lib/input.mjs

@@ -0,0 +1,55 @@
+import fs from 'node:fs/promises'
+
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return null
+  }
+
+  // In non-TTY environments, check if data is available with a short timeout
+  // to avoid hanging when no data is being piped
+  return new Promise((resolve) => {
+    const chunks = []
+    let hasData = false
+
+    const timeout = setTimeout(() => {
+      if (!hasData) {
+        process.stdin.removeAllListeners()
+        process.stdin.pause()
+        resolve(null)
+      }
+    }, 10)
+
+    process.stdin.on('readable', () => {
+      let chunk = process.stdin.read()
+      while (chunk !== null) {
+        hasData = true
+        chunks.push(chunk)
+        chunk = process.stdin.read()
+      }
+    })
+
+    process.stdin.on('end', () => {
+      clearTimeout(timeout)
+      if (chunks.length === 0) {
+        resolve(null)
+      } else {
+        const content = Buffer.concat(chunks).toString('utf8').trim()
+        resolve(content || null)
+      }
+    })
+  })
+}
+
+async function readFile(filePath) {
+  const content = await fs.readFile(filePath, 'utf8')
+  return content.trim() || null
+}
+
+function buildMessage(prompt, content) {
+  if (prompt && content) {
+    return `${prompt}:\n\n${content}`
+  }
+  return content || prompt || null
+}
+
+export { readStdin, readFile, buildMessage }

package/lib/providers.mjs

@@ -1,11 +1,13 @@
 import { createAnthropic } from '@ai-sdk/anthropic'
 import { createOpenAI } from '@ai-sdk/openai'
 import { createPerplexity } from '@ai-sdk/perplexity'
+import { createXai } from '@ai-sdk/xai'
 
 const DEFAULT_MODELS = {
   perplexity: 'sonar',
   openai: 'gpt-4o',
-  anthropic: 'claude-sonnet-4-20250514'
+  anthropic: 'claude-sonnet-4-20250514',
+  xai: 'grok-4'
 }
 
 // Perplexity doesn't have a models list API, so we hardcode these
@@ -17,6 +19,20 @@ const PERPLEXITY_MODELS = [
   { id: 'sonar-deep-research', description: 'Deep research sessions' }
 ]
 
+// xAI doesn't have a public models list API, so we hardcode these
+const XAI_MODELS = [
+  { id: 'grok-4-1-fast-reasoning', description: 'Grok 4.1 fast with reasoning' },
+  { id: 'grok-4-1-fast-non-reasoning', description: 'Grok 4.1 fast without reasoning' },
+  { id: 'grok-code-fast-1', description: 'Grok optimized for code' },
+  { id: 'grok-4-fast-reasoning', description: 'Grok 4 fast with reasoning' },
+  { id: 'grok-4-fast-non-reasoning', description: 'Grok 4 fast without reasoning' },
+  { id: 'grok-4-0709', description: 'Grok 4 flagship model' },
+  { id: 'grok-3-mini', description: 'Lightweight Grok 3 model' },
+  { id: 'grok-3', description: 'Grok 3 base model' },
+  { id: 'grok-2-vision-1212', description: 'Grok 2 with vision capabilities' },
+  { id: 'grok-2-image-1212', description: 'Image generation model' }
+]
+
 async function fetchOpenAiModels(apiKey) {
   const response = await fetch('https://api.openai.com/v1/models', {
     // biome-ignore lint/style/useNamingConvention: headers use standard capitalization
@@ -71,6 +87,9 @@ async function listModels(provider, config) {
       return fetchAnthropicModels(apiKey)
     }
 
+    case 'xai':
+      return XAI_MODELS
+
     default:
       throw new Error(`Unknown provider: ${provider}`)
   }
@@ -117,6 +136,19 @@ function getProvider(providerName, config) {
         modelName
       }
     }
+    case 'xai': {
+      const apiKey = config.XAI_API_KEY
+      if (!apiKey) {
+        throw new Error('XAI_API_KEY not found in config')
+      }
+      const modelName = config.XAI_MODEL || DEFAULT_MODELS.xai
+      const xai = createXai({ apiKey })
+      return {
+        model: xai(modelName),
+        name: 'xai',
+        modelName
+      }
+    }
     default:
       throw new Error(`Unknown provider: ${providerName}`)
   }
@@ -126,9 +158,10 @@ function determineProvider(options, config = {}) {
   if (options.openai) return 'openai'
   if (options.anthropic) return 'anthropic'
   if (options.perplexity) return 'perplexity'
+  if (options.xai) return 'xai'
 
   const defaultProvider = config.DEFAULT_PROVIDER?.toLowerCase()
-  if (defaultProvider && ['perplexity', 'openai', 'anthropic'].includes(defaultProvider)) {
+  if (defaultProvider && ['perplexity', 'openai', 'anthropic', 'xai'].includes(defaultProvider)) {
     return defaultProvider
   }
 

package/lib/stream.mjs

@@ -1,6 +1,13 @@
 import { generateText, streamText } from 'ai'
 
-async function streamResponse(model, messages) {
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`
+  return `${(ms / 1000).toFixed(1)}s`
+}
+
+async function streamResponse(model, messages, modelName) {
+  const startTime = Date.now()
+
   const result = streamText({
     model,
     messages
@@ -29,27 +36,35 @@ async function streamResponse(model, messages) {
     })
   }
 
+  // Display status line
+  const duration = Date.now() - startTime
+  process.stdout.write(`\n\x1b[2m${modelName} · ${formatDuration(duration)}\x1b[0m\n`)
+
   return fullText
 }
 
 async function generateResponse(model, messages) {
+  const startTime = Date.now()
+
   const { text, sources } = await generateText({
     model,
     messages
   })
 
-  return { text, sources }
+  const duration = Date.now() - startTime
+  return { text, sources, duration }
 }
 
-function buildJsonOutput(conversation, response, sources) {
-  const lastUserMessage = conversation.messages[conversation.messages.length - 1]
+function buildJsonOutput(conversation, response, sources, duration) {
+  const lastUserMessage = conversation.messages.findLast((m) => m.role === 'user')
   const output = {
     provider: conversation.provider,
     model: conversation.model,
     question: lastUserMessage?.content || '',
     response,
     conversationId: conversation.id,
-    messageCount: conversation.messages.length + 1
+    messageCount: conversation.messages.length + 1,
+    durationMs: duration
   }
 
   if (sources?.length > 0) {
@@ -59,8 +74,8 @@ function buildJsonOutput(conversation, response, sources) {
   return output
 }
 
-function outputJson(conversation, response, sources) {
-  const output = buildJsonOutput(conversation, response, sources)
+function outputJson(conversation, response, sources, duration) {
+  const output = buildJsonOutput(conversation, response, sources, duration)
   console.log(JSON.stringify(output, null, 2))
 }
 

package/package.json

@@ -1,9 +1,21 @@
 {
   "name": "askimo",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "A CLI tool for communicating with AI providers (Perplexity, OpenAI, Anthropic)",
   "license": "Apache-2.0",
   "author": "Amit Tal",
+  "keywords": [
+    "cli",
+    "ai",
+    "llm",
+    "perplexity",
+    "openai",
+    "anthropic",
+    "claude",
+    "gpt",
+    "chatbot",
+    "terminal"
+  ],
   "type": "module",
   "bin": {
     "askimo": "./index.mjs"
@@ -27,6 +39,7 @@
     "@ai-sdk/anthropic": "^2.0.53",
     "@ai-sdk/openai": "^2.0.76",
     "@ai-sdk/perplexity": "^2.0.21",
+    "@ai-sdk/xai": "^2.0.40",
     "@inquirer/input": "^5.0.2",
     "ai": "^5.0.106",
     "commander": "^14.0.2"

package/test/input.mjs

@@ -0,0 +1,53 @@
+import test from 'ava'
+import { buildMessage } from '../lib/input.mjs'
+
+test('buildMessage combines prompt and content with colon format', (t) => {
+  const result = buildMessage('explain this', 'const x = 1')
+  t.is(result, 'explain this:\n\nconst x = 1')
+})
+
+test('buildMessage returns content only when no prompt', (t) => {
+  const result = buildMessage(null, 'some content')
+  t.is(result, 'some content')
+})
+
+test('buildMessage returns content only when prompt is undefined', (t) => {
+  const result = buildMessage(undefined, 'some content')
+  t.is(result, 'some content')
+})
+
+test('buildMessage returns prompt only when no content', (t) => {
+  const result = buildMessage('what is 2+2', null)
+  t.is(result, 'what is 2+2')
+})
+
+test('buildMessage returns prompt only when content is undefined', (t) => {
+  const result = buildMessage('what is 2+2', undefined)
+  t.is(result, 'what is 2+2')
+})
+
+test('buildMessage returns null when both are null', (t) => {
+  const result = buildMessage(null, null)
+  t.is(result, null)
+})
+
+test('buildMessage returns null when both are undefined', (t) => {
+  const result = buildMessage(undefined, undefined)
+  t.is(result, null)
+})
+
+test('buildMessage handles empty string prompt as falsy', (t) => {
+  const result = buildMessage('', 'content')
+  t.is(result, 'content')
+})
+
+test('buildMessage handles empty string content as falsy', (t) => {
+  const result = buildMessage('prompt', '')
+  t.is(result, 'prompt')
+})
+
+test('buildMessage preserves multiline content', (t) => {
+  const content = 'line 1\nline 2\nline 3'
+  const result = buildMessage('summarize', content)
+  t.is(result, 'summarize:\n\nline 1\nline 2\nline 3')
+})

package/test/stream.mjs

@@ -45,6 +45,17 @@ test('buildJsonOutput extracts question from last user message', (t) => {
   t.is(output.question, 'Second question')
 })
 
+test('buildJsonOutput finds user message even when assistant message is last', (t) => {
+  const conversation = createMockConversation({
+    messages: [
+      { role: 'user', content: 'My question' },
+      { role: 'assistant', content: 'My answer' }
+    ]
+  })
+  const output = buildJsonOutput(conversation, 'response')
+  t.is(output.question, 'My question')
+})
+
 test('buildJsonOutput returns empty question when no messages', (t) => {
   const conversation = createMockConversation({ messages: [] })
   const output = buildJsonOutput(conversation, 'response')