@hasna/terminal 2.3.1 → 2.3.2

package/dist/parsers/tests.js

@@ -0,0 +1,89 @@
+// Parser for test runner output (jest, vitest, bun test, pytest, go test)
+export const testParser = {
+    name: "test",
+    detect(command, output) {
+        if (/\b(jest|vitest|bun\s+test|pytest|go\s+test|mocha|ava|tap)\b/.test(command))
+            return true;
+        if (/\b(npm|bun|pnpm|yarn)\s+(run\s+)?test\b/.test(command))
+            return true;
+        // Detect by output patterns
+        return /Tests:\s+\d+/.test(output) || /\d+\s+(passing|passed|failed)/.test(output) || /PASS|FAIL/.test(output);
+    },
+    parse(_command, output) {
+        const failures = [];
+        let passed = 0, failed = 0, skipped = 0, duration;
+        // Jest/Vitest style: Tests: 5 passed, 2 failed, 7 total
+        const jestMatch = output.match(/Tests:\s+(?:(\d+)\s+passed)?[,\s]*(?:(\d+)\s+failed)?[,\s]*(?:(\d+)\s+skipped)?[,\s]*(\d+)\s+total/);
+        if (jestMatch) {
+            passed = parseInt(jestMatch[1] ?? "0");
+            failed = parseInt(jestMatch[2] ?? "0");
+            skipped = parseInt(jestMatch[3] ?? "0");
+        }
+        // Bun test style: 5 pass, 2 fail
+        const bunMatch = output.match(/(\d+)\s+pass.*?(\d+)\s+fail/);
+        if (!jestMatch && bunMatch) {
+            passed = parseInt(bunMatch[1]);
+            failed = parseInt(bunMatch[2]);
+        }
+        // Pytest style: 5 passed, 2 failed
+        const pytestMatch = output.match(/(\d+)\s+passed(?:.*?(\d+)\s+failed)?/);
+        if (!jestMatch && !bunMatch && pytestMatch) {
+            passed = parseInt(pytestMatch[1]);
+            failed = parseInt(pytestMatch[2] ?? "0");
+        }
+        // Go test: ok/FAIL + count
+        const goPassMatch = output.match(/ok\s+\S+\s+([\d.]+s)/);
+        const goFailMatch = output.match(/FAIL\s+\S+/);
+        if (!jestMatch && !bunMatch && !pytestMatch && (goPassMatch || goFailMatch)) {
+            const passLines = (output.match(/--- PASS/g) || []).length;
+            const failLines = (output.match(/--- FAIL/g) || []).length;
+            passed = passLines;
+            failed = failLines;
+            if (goPassMatch)
+                duration = goPassMatch[1];
+        }
+        // Duration
+        const timeMatch = output.match(/Time:\s+([\d.]+\s*(?:s|ms|m))/i) || output.match(/in\s+([\d.]+\s*(?:s|ms|m))/i);
+        if (timeMatch)
+            duration = timeMatch[1];
+        // Extract failure details: lines starting with FAIL or ✗ or ×
+        const lines = output.split("\n");
+        let capturingFailure = false;
+        let currentTest = "";
+        let currentError = [];
+        for (const line of lines) {
+            const failMatch = line.match(/(?:FAIL|✗|×|✕)\s+(.+)/);
+            if (failMatch) {
+                if (capturingFailure && currentTest) {
+                    failures.push({ test: currentTest, error: currentError.join("\n").trim() });
+                }
+                currentTest = failMatch[1].trim();
+                currentError = [];
+                capturingFailure = true;
+                continue;
+            }
+            if (capturingFailure) {
+                if (line.match(/^(PASS|✓|✔|FAIL|✗|×|✕)\s/) || line.match(/^Tests:|^\d+ pass/)) {
+                    failures.push({ test: currentTest, error: currentError.join("\n").trim() });
+                    capturingFailure = false;
+                    currentTest = "";
+                    currentError = [];
+                }
+                else {
+                    currentError.push(line);
+                }
+            }
+        }
+        if (capturingFailure && currentTest) {
+            failures.push({ test: currentTest, error: currentError.join("\n").trim() });
+        }
+        return {
+            passed,
+            failed,
+            skipped,
+            total: passed + failed + skipped,
+            duration,
+            failures,
+        };
+    },
+};

package/dist/providers/anthropic.js

@@ -0,0 +1,39 @@
+import Anthropic from "@anthropic-ai/sdk";
+export class AnthropicProvider {
+    name = "anthropic";
+    client;
+    constructor() {
+        this.client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+    }
+    isAvailable() {
+        return !!process.env.ANTHROPIC_API_KEY;
+    }
+    async complete(prompt, options) {
+        const message = await this.client.messages.create({
+            model: options.model ?? "claude-haiku-4-5-20251001",
+            max_tokens: options.maxTokens ?? 256,
+            system: options.system,
+            messages: [{ role: "user", content: prompt }],
+        });
+        const block = message.content[0];
+        if (block.type !== "text")
+            throw new Error("Unexpected response type");
+        return block.text.trim();
+    }
+    async stream(prompt, options, callbacks) {
+        let result = "";
+        const stream = await this.client.messages.stream({
+            model: options.model ?? "claude-haiku-4-5-20251001",
+            max_tokens: options.maxTokens ?? 256,
+            system: options.system,
+            messages: [{ role: "user", content: prompt }],
+        });
+        for await (const chunk of stream) {
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                result += chunk.delta.text;
+                callbacks.onToken(result.trim());
+            }
+        }
+        return result.trim();
+    }
+}

package/dist/providers/base.js

@@ -0,0 +1,4 @@
+// Provider interface for LLM backends (Anthropic, Cerebras, etc.)
+export const DEFAULT_PROVIDER_CONFIG = {
+    provider: "auto",
+};

package/dist/providers/cerebras.js

@@ -0,0 +1,95 @@
+// Cerebras provider — uses OpenAI-compatible API
+// Default for open-source users. Fast inference on Llama models.
+const CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
+const DEFAULT_MODEL = "qwen-3-235b-a22b-instruct-2507";
+export class CerebrasProvider {
+    name = "cerebras";
+    apiKey;
+    constructor() {
+        this.apiKey = process.env.CEREBRAS_API_KEY ?? "";
+    }
+    isAvailable() {
+        return !!process.env.CEREBRAS_API_KEY;
+    }
+    async complete(prompt, options) {
+        const model = options.model ?? DEFAULT_MODEL;
+        const res = await fetch(`${CEREBRAS_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(`Cerebras API error ${res.status}: ${text}`);
+        }
+        const json = (await res.json());
+        return (json.choices?.[0]?.message?.content ?? "").trim();
+    }
+    async stream(prompt, options, callbacks) {
+        const model = options.model ?? DEFAULT_MODEL;
+        const res = await fetch(`${CEREBRAS_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(`Cerebras 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);
+                    const delta = parsed.choices?.[0]?.delta?.content;
+                    if (delta) {
+                        result += delta;
+                        callbacks.onToken(result.trim());
+                    }
+                }
+                catch {
+                    // skip malformed chunks
+                }
+            }
+        }
+        return result.trim();
+    }
+}

package/dist/providers/groq.js

@@ -0,0 +1,95 @@
+// Groq provider — uses OpenAI-compatible API
+// Ultra-fast inference. Supports Llama, Qwen, Kimi models.
+const GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+const DEFAULT_MODEL = "openai/gpt-oss-120b";
+export class GroqProvider {
+    name = "groq";
+    apiKey;
+    constructor() {
+        this.apiKey = process.env.GROQ_API_KEY ?? "";
+    }
+    isAvailable() {
+        return !!process.env.GROQ_API_KEY;
+    }
+    async complete(prompt, options) {
+        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());
+        return (json.choices?.[0]?.message?.content ?? "").trim();
+    }
+    async stream(prompt, options, callbacks) {
+        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);
+                    const delta = parsed.choices?.[0]?.delta?.content;
+                    if (delta) {
+                        result += delta;
+                        callbacks.onToken(result.trim());
+                    }
+                }
+                catch {
+                    // skip malformed chunks
+                }
+            }
+        }
+        return result.trim();
+    }
+}

package/dist/providers/index.js

@@ -0,0 +1,73 @@
+// Provider auto-detection and management
+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 { DEFAULT_PROVIDER_CONFIG } from "./base.js";
+let _provider = null;
+/** Get the active LLM provider. Auto-detects based on available API keys. */
+export function getProvider(config) {
+    if (_provider)
+        return _provider;
+    const cfg = config ?? DEFAULT_PROVIDER_CONFIG;
+    _provider = resolveProvider(cfg);
+    return _provider;
+}
+/** Reset the cached provider (useful when config changes). */
+export function resetProvider() {
+    _provider = null;
+}
+function resolveProvider(config) {
+    if (config.provider === "cerebras") {
+        const p = new CerebrasProvider();
+        if (!p.isAvailable())
+            throw new Error("CEREBRAS_API_KEY not set. Run: export CEREBRAS_API_KEY=your-key");
+        return p;
+    }
+    if (config.provider === "anthropic") {
+        const p = new AnthropicProvider();
+        if (!p.isAvailable())
+            throw new Error("ANTHROPIC_API_KEY not set. Run: export ANTHROPIC_API_KEY=your-key");
+        return p;
+    }
+    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 Cerebras (qwen-235b, fast + accurate), then xAI, then Groq, then Anthropic
+    const cerebras = new CerebrasProvider();
+    if (cerebras.isAvailable())
+        return cerebras;
+    const xai = new XaiProvider();
+    if (xai.isAvailable())
+        return xai;
+    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 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)");
+}
+/** List available providers (for onboarding UI). */
+export function availableProviders() {
+    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/dist/providers/xai.js

@@ -0,0 +1,95 @@
+// xAI/Grok provider — uses OpenAI-compatible API
+// grok-code-fast-1 for code tasks, grok-4-fast for general queries.
+const XAI_BASE_URL = "https://api.x.ai/v1";
+const DEFAULT_MODEL = "grok-code-fast-1";
+export class XaiProvider {
+    name = "xai";
+    apiKey;
+    constructor() {
+        this.apiKey = process.env.XAI_API_KEY ?? "";
+    }
+    isAvailable() {
+        return !!process.env.XAI_API_KEY;
+    }
+    async complete(prompt, options) {
+        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());
+        return (json.choices?.[0]?.message?.content ?? "").trim();
+    }
+    async stream(prompt, options, callbacks) {
+        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);
+                    const delta = parsed.choices?.[0]?.delta?.content;
+                    if (delta) {
+                        result += delta;
+                        callbacks.onToken(result.trim());
+                    }
+                }
+                catch {
+                    // skip malformed chunks
+                }
+            }
+        }
+        return result.trim();
+    }
+}

package/dist/recipes/model.js

@@ -0,0 +1,20 @@
+// Recipes data model — reusable command templates with collections and projects
+/** Generate a short random ID */
+export function genId() {
+    return Math.random().toString(36).slice(2, 10);
+}
+/** Substitute variables in a command template */
+export function substituteVariables(command, vars) {
+    let result = command;
+    for (const [name, value] of Object.entries(vars)) {
+        result = result.replace(new RegExp(`\\{${name}\\}`, "g"), value);
+    }
+    return result;
+}
+/** Extract variable placeholders from a command */
+export function extractVariables(command) {
+    const matches = command.match(/\{(\w+)\}/g);
+    if (!matches)
+        return [];
+    return [...new Set(matches.map(m => m.slice(1, -1)))];
+}

package/dist/recipes/storage.js

@@ -0,0 +1,136 @@
+// Recipes storage — global (~/.terminal/recipes.json) + per-project (.terminal/recipes.json)
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { genId, extractVariables } from "./model.js";
+const GLOBAL_DIR = join(homedir(), ".terminal");
+const GLOBAL_FILE = join(GLOBAL_DIR, "recipes.json");
+function projectFile(projectPath) {
+    return join(projectPath, ".terminal", "recipes.json");
+}
+function loadStore(filePath) {
+    if (!existsSync(filePath))
+        return { recipes: [], collections: [] };
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return { recipes: [], collections: [] };
+    }
+}
+function saveStore(filePath, store) {
+    const dir = filePath.replace(/\/[^/]+$/, "");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, JSON.stringify(store, null, 2));
+}
+// ── CRUD operations ──────────────────────────────────────────────────────────
+/** Get all recipes (merged: global + project-scoped) */
+export function listRecipes(projectPath) {
+    const global = loadStore(GLOBAL_FILE).recipes;
+    if (!projectPath)
+        return global;
+    const project = loadStore(projectFile(projectPath)).recipes;
+    return [...project, ...global]; // project recipes first (higher priority)
+}
+/** Get recipes filtered by collection */
+export function listByCollection(collection, projectPath) {
+    return listRecipes(projectPath).filter(r => r.collection === collection);
+}
+/** Get a recipe by name */
+export function getRecipe(name, projectPath) {
+    return listRecipes(projectPath).find(r => r.name === name) ?? null;
+}
+/** Create a recipe */
+export function createRecipe(opts) {
+    const filePath = opts.project ? projectFile(opts.project) : GLOBAL_FILE;
+    const store = loadStore(filePath);
+    // Prevent duplicates — update existing if same name
+    const existingIdx = store.recipes.findIndex(r => r.name === opts.name);
+    if (existingIdx >= 0) {
+        store.recipes[existingIdx].command = opts.command;
+        store.recipes[existingIdx].updatedAt = Date.now();
+        if (opts.description)
+            store.recipes[existingIdx].description = opts.description;
+        if (opts.tags)
+            store.recipes[existingIdx].tags = opts.tags;
+        if (opts.collection)
+            store.recipes[existingIdx].collection = opts.collection;
+        saveStore(filePath, store);
+        return store.recipes[existingIdx];
+    }
+    // Auto-detect variables from command if not explicitly provided
+    const detectedVars = extractVariables(opts.command);
+    const variables = opts.variables ?? detectedVars.map(name => ({ name, required: true }));
+    const recipe = {
+        id: genId(),
+        name: opts.name,
+        description: opts.description,
+        command: opts.command,
+        tags: opts.tags ?? [],
+        collection: opts.collection,
+        project: opts.project,
+        variables,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+    };
+    store.recipes.push(recipe);
+    saveStore(filePath, store);
+    return recipe;
+}
+/** Delete a recipe by name — tries project first, then global */
+export function deleteRecipe(name, projectPath) {
+    // Try project-scoped first
+    if (projectPath) {
+        const pFile = projectFile(projectPath);
+        const pStore = loadStore(pFile);
+        const before = pStore.recipes.length;
+        pStore.recipes = pStore.recipes.filter(r => r.name !== name);
+        if (pStore.recipes.length < before) {
+            saveStore(pFile, pStore);
+            return true;
+        }
+    }
+    // Fall back to global
+    const store = loadStore(GLOBAL_FILE);
+    const before = store.recipes.length;
+    store.recipes = store.recipes.filter(r => r.name !== name);
+    if (store.recipes.length < before) {
+        saveStore(GLOBAL_FILE, store);
+        return true;
+    }
+    return false;
+}
+// ── Collections ──────────────────────────────────────────────────────────────
+export function listCollections(projectPath) {
+    const global = loadStore(GLOBAL_FILE).collections;
+    if (!projectPath)
+        return global;
+    const project = loadStore(projectFile(projectPath)).collections;
+    return [...project, ...global];
+}
+export function createCollection(opts) {
+    const filePath = opts.project ? projectFile(opts.project) : GLOBAL_FILE;
+    const store = loadStore(filePath);
+    // Prevent duplicates — return existing if same name
+    const existing = store.collections.find(c => c.name === opts.name);
+    if (existing)
+        return existing;
+    const collection = {
+        id: genId(),
+        name: opts.name,
+        description: opts.description,
+        project: opts.project,
+        createdAt: Date.now(),
+    };
+    store.collections.push(collection);
+    saveStore(filePath, store);
+    return collection;
+}
+/** Initialize project-scoped recipes file */
+export function initProject(projectPath) {
+    const file = projectFile(projectPath);
+    if (!existsSync(file)) {
+        saveStore(file, { recipes: [], collections: [] });
+    }
+}