@hasna/terminal 2.0.4 → 2.2.0

package/src/output-processor.ts

@@ -4,6 +4,7 @@
 import { getProvider } from "./providers/index.js";
 import { estimateTokens } from "./parsers/index.js";
 import { recordSaving } from "./economy.js";
+import { discoverOutputHints } from "./context-hints.js";
 
 export interface ProcessedOutput {
   /** AI-generated summary (concise, structured) */
@@ -79,27 +80,15 @@ export async function processOutput(
   }
 
   try {
-    // Pre-parse: if output contains clear pass/fail counts, extract and return directly
-    // No hardcoded test runner list — works for ANY tool that outputs "X pass, Y fail"
-    const passMatch = output.match(/(\d+)\s+pass/i);
-    const failMatch = output.match(/(\d+)\s+fail/i);
-    // Pre-parse fires when output has BOTH pass+fail counts AND the user asked about tests
-    if (passMatch && failMatch && originalPrompt && /test|pass|fail/i.test(originalPrompt)) {
-      const passed = parseInt(passMatch[1]);
-      const failed = parseInt(failMatch[1]);
-      const answer = failed === 0
-        ? `✓ Yes, all ${passed} tests pass.`
-        : `✗ ${failed} of ${passed + failed} tests failed.`;
-      const savedTokens = estimateTokens(output) - estimateTokens(answer);
-      return {
-        summary: answer, full: output, tokensSaved: Math.max(0, savedTokens),
-        aiTokensUsed: 0, aiProcessed: true, aiCostUsd: 0, savingsValueUsd: 0, netSavingsUsd: 0,
-      };
-    }
+    // Discover output hints — regex discovers patterns, AI decides what matters
+    const outputHints = discoverOutputHints(output, command);
+    const hintsBlock = outputHints.length > 0
+      ? `\n\nOUTPUT OBSERVATIONS:\n${outputHints.join("\n")}`
+      : "";
 
     const provider = getProvider();
     const summary = await provider.complete(
-      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}`,
+      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}`,
       {
         system: SUMMARIZE_PROMPT,
         maxTokens: 300,

package/src/providers/base.ts

@@ -24,9 +24,11 @@ export interface LLMProvider {
 }
 
 export interface ProviderConfig {
-  provider: "cerebras" | "anthropic" | "auto";
+  provider: "cerebras" | "anthropic" | "groq" | "xai" | "auto";
   cerebrasModel?: string;
   anthropicModel?: string;
+  groqModel?: string;
+  xaiModel?: string;
 }
 
 export const DEFAULT_PROVIDER_CONFIG: ProviderConfig = {

package/src/providers/groq.ts

@@ -0,0 +1,108 @@
+// Groq provider — uses OpenAI-compatible API
+// Ultra-fast inference. Supports Llama, Qwen, Kimi models.
+
+import type { LLMProvider, ProviderOptions, StreamCallbacks } from "./base.js";
+
+const GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+const DEFAULT_MODEL = "openai/gpt-oss-120b";
+
+export class GroqProvider implements LLMProvider {
+  readonly name = "groq";
+  private apiKey: string;
+
+  constructor() {
+    this.apiKey = process.env.GROQ_API_KEY ?? "";
+  }
+
+  isAvailable(): boolean {
+    return !!process.env.GROQ_API_KEY;
+  }
+
+  async complete(prompt: string, options: ProviderOptions): Promise<string> {
+    const model = options.model ?? DEFAULT_MODEL;
+    const res = await fetch(`${GROQ_BASE_URL}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: options.maxTokens ?? 256,
+        messages: [
+          { role: "system", content: options.system },
+          { role: "user", content: prompt },
+        ],
+      }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Groq API error ${res.status}: ${text}`);
+    }
+
+    const json = (await res.json()) as any;
+    return (json.choices?.[0]?.message?.content ?? "").trim();
+  }
+
+  async stream(prompt: string, options: ProviderOptions, callbacks: StreamCallbacks): Promise<string> {
+    const model = options.model ?? DEFAULT_MODEL;
+    const res = await fetch(`${GROQ_BASE_URL}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: options.maxTokens ?? 256,
+        stream: true,
+        messages: [
+          { role: "system", content: options.system },
+          { role: "user", content: prompt },
+        ],
+      }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Groq API error ${res.status}: ${text}`);
+    }
+
+    let result = "";
+    const reader = res.body?.getReader();
+    if (!reader) throw new Error("No response body");
+
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (data === "[DONE]") break;
+
+        try {
+          const parsed = JSON.parse(data) as any;
+          const delta = parsed.choices?.[0]?.delta?.content;
+          if (delta) {
+            result += delta;
+            callbacks.onToken(result.trim());
+          }
+        } catch {
+          // skip malformed chunks
+        }
+      }
+    }
+
+    return result.trim();
+  }
+}

package/src/providers/index.ts

@@ -4,6 +4,8 @@ import type { LLMProvider, ProviderConfig } from "./base.js";
 import { DEFAULT_PROVIDER_CONFIG } from "./base.js";
 import { AnthropicProvider } from "./anthropic.js";
 import { CerebrasProvider } from "./cerebras.js";
+import { GroqProvider } from "./groq.js";
+import { XaiProvider } from "./xai.js";
 
 export type { LLMProvider, ProviderOptions, StreamCallbacks, ProviderConfig } from "./base.js";
 export { DEFAULT_PROVIDER_CONFIG } from "./base.js";
@@ -37,17 +39,37 @@ function resolveProvider(config: ProviderConfig): LLMProvider {
     return p;
   }
 
-  // auto: prefer Cerebras (open-source friendly), fall back to Anthropic
+  if (config.provider === "groq") {
+    const p = new GroqProvider();
+    if (!p.isAvailable()) throw new Error("GROQ_API_KEY not set. Run: export GROQ_API_KEY=your-key");
+    return p;
+  }
+
+  if (config.provider === "xai") {
+    const p = new XaiProvider();
+    if (!p.isAvailable()) throw new Error("XAI_API_KEY not set. Run: export XAI_API_KEY=your-key");
+    return p;
+  }
+
+  // auto: prefer xAI (code-optimized), then Cerebras, then Groq, then Anthropic
+  const xai = new XaiProvider();
+  if (xai.isAvailable()) return xai;
+
   const cerebras = new CerebrasProvider();
   if (cerebras.isAvailable()) return cerebras;
 
+  const groq = new GroqProvider();
+  if (groq.isAvailable()) return groq;
+
   const anthropic = new AnthropicProvider();
   if (anthropic.isAvailable()) return anthropic;
 
   throw new Error(
     "No API key found. Set one of:\n" +
     "  export CEREBRAS_API_KEY=your-key  (free, open-source)\n" +
-    "  export ANTHROPIC_API_KEY=your-key (Claude)"
+    "  export GROQ_API_KEY=your-key      (free, fast)\n" +
+    "  export XAI_API_KEY=your-key       (Grok, code-optimized)\n" +
+    "  export ANTHROPIC_API_KEY=your-key  (Claude)"
   );
 }
 
@@ -55,6 +77,8 @@ function resolveProvider(config: ProviderConfig): LLMProvider {
 export function availableProviders(): { name: string; available: boolean }[] {
   return [
     { name: "cerebras", available: new CerebrasProvider().isAvailable() },
+    { name: "groq", available: new GroqProvider().isAvailable() },
+    { name: "xai", available: new XaiProvider().isAvailable() },
     { name: "anthropic", available: new AnthropicProvider().isAvailable() },
   ];
 }

package/src/providers/providers.test.ts

@@ -4,9 +4,11 @@ import { availableProviders, resetProvider } from "./index.js";
 describe("providers", () => {
   it("lists available providers", () => {
     const providers = availableProviders();
-    expect(providers.length).toBe(2);
+    expect(providers.length).toBe(4);
     expect(providers[0].name).toBe("cerebras");
-    expect(providers[1].name).toBe("anthropic");
+    expect(providers[1].name).toBe("groq");
+    expect(providers[2].name).toBe("xai");
+    expect(providers[3].name).toBe("anthropic");
   });
 
   it("resetProvider clears cache", () => {

package/src/providers/xai.ts

@@ -0,0 +1,108 @@
+// xAI/Grok provider — uses OpenAI-compatible API
+// grok-code-fast-1 for code tasks, grok-4-fast for general queries.
+
+import type { LLMProvider, ProviderOptions, StreamCallbacks } from "./base.js";
+
+const XAI_BASE_URL = "https://api.x.ai/v1";
+const DEFAULT_MODEL = "grok-code-fast-1";
+
+export class XaiProvider implements LLMProvider {
+  readonly name = "xai";
+  private apiKey: string;
+
+  constructor() {
+    this.apiKey = process.env.XAI_API_KEY ?? "";
+  }
+
+  isAvailable(): boolean {
+    return !!process.env.XAI_API_KEY;
+  }
+
+  async complete(prompt: string, options: ProviderOptions): Promise<string> {
+    const model = options.model ?? DEFAULT_MODEL;
+    const res = await fetch(`${XAI_BASE_URL}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: options.maxTokens ?? 256,
+        messages: [
+          { role: "system", content: options.system },
+          { role: "user", content: prompt },
+        ],
+      }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`xAI API error ${res.status}: ${text}`);
+    }
+
+    const json = (await res.json()) as any;
+    return (json.choices?.[0]?.message?.content ?? "").trim();
+  }
+
+  async stream(prompt: string, options: ProviderOptions, callbacks: StreamCallbacks): Promise<string> {
+    const model = options.model ?? DEFAULT_MODEL;
+    const res = await fetch(`${XAI_BASE_URL}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: options.maxTokens ?? 256,
+        stream: true,
+        messages: [
+          { role: "system", content: options.system },
+          { role: "user", content: prompt },
+        ],
+      }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`xAI API error ${res.status}: ${text}`);
+    }
+
+    let result = "";
+    const reader = res.body?.getReader();
+    if (!reader) throw new Error("No response body");
+
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (data === "[DONE]") break;
+
+        try {
+          const parsed = JSON.parse(data) as any;
+          const delta = parsed.choices?.[0]?.delta?.content;
+          if (delta) {
+            result += delta;
+            callbacks.onToken(result.trim());
+          }
+        } catch {
+          // skip malformed chunks
+        }
+      }
+    }
+
+    return result.trim();
+  }
+}