@hasna/terminal 4.3.1 → 4.3.2

package/dist/providers/xai.js

@@ -0,0 +1,8 @@
+// xAI/Grok provider — code-optimized models
+import { OpenAICompatibleProvider } from "./openai-compat.js";
+export class XaiProvider extends OpenAICompatibleProvider {
+    name = "xai";
+    baseUrl = "https://api.x.ai/v1";
+    defaultModel = "grok-code-fast-1";
+    apiKeyEnvVar = "XAI_API_KEY";
+}

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,153 @@
+// Recipes storage — global (~/.hasna/terminal/recipes.json) + per-project (.terminal/recipes.json)
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { genId, extractVariables } from "./model.js";
+import { getTerminalDir } from "../paths.js";
+const GLOBAL_DIR = getTerminalDir();
+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));
+}
+// ── Built-in system recipes (always available, zero config) ─────────────────
+const SYSTEM_RECIPES = [
+    // Git workflows
+    { id: "sys-commit-push", name: "commit-push", description: "Stage all, commit, push to origin", command: "git add -A && git commit -m \"{message}\" && git push", tags: ["git"], collection: "git", variables: [{ name: "message", required: true }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-pr", name: "create-pr", description: "Create GitHub PR from current branch", command: "gh pr create --title \"{title}\" --body \"{body}\"", tags: ["git", "github"], collection: "git", variables: [{ name: "title", required: true }, { name: "body", default: "" }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-stash", name: "stash-switch", description: "Stash changes, switch branch, pop", command: "git stash && git checkout {branch} && git stash pop", tags: ["git"], collection: "git", variables: [{ name: "branch", required: true }], createdAt: 0, updatedAt: 0 },
+    // Quality checks
+    { id: "sys-todos", name: "find-todos", description: "Find all TODO/FIXME/HACK in source code", command: "grep -rn 'TODO\\|FIXME\\|HACK\\|XXX' {path} --include='*.ts' --include='*.tsx' --include='*.js' --include='*.py' --include='*.go' --include='*.rs' --include='*.java' --include='*.rb'", tags: ["quality"], collection: "quality", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-deadcode", name: "find-unused-exports", description: "Find exported symbols that may be unused", command: "grep -rn 'export ' {path} --include='*.ts' | sed 's/.*export //' | sed 's/[(<:].*//' | sort -u", tags: ["quality"], collection: "quality", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-security", name: "security-scan", description: "Scan for common security anti-patterns", command: "grep -rn 'eval\\|exec\\|spawn\\|innerHTML\\|dangerouslySetInnerHTML\\|password.*=.*[\"'\\']' {path} --include='*.ts' --include='*.js' --include='*.py'", tags: ["security"], collection: "quality", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+    // Project info
+    { id: "sys-deps", name: "list-deps", description: "Show project dependencies", command: "cat package.json 2>/dev/null | grep -A 100 '\"dependencies\"' | head -30 || cat requirements.txt 2>/dev/null || cat Cargo.toml 2>/dev/null | grep -A 50 'dependencies'", tags: ["deps"], collection: "project", variables: [], createdAt: 0, updatedAt: 0 },
+    { id: "sys-size", name: "project-size", description: "Count lines of code by file type", command: "find {path} -not -path '*/node_modules/*' -not -path '*/dist/*' -not -path '*/.git/*' -type f | xargs wc -l 2>/dev/null | sort -rn | head -20", tags: ["stats"], collection: "project", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+    // Process management
+    { id: "sys-port", name: "kill-port", description: "Kill whatever is running on a port", command: "lsof -ti :{port} | xargs kill -9 2>/dev/null || echo 'Port {port} is free'", tags: ["process"], collection: "system", variables: [{ name: "port", required: true }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-disk", name: "disk-usage", description: "Show disk usage of current directory", command: "du -sh {path}/* 2>/dev/null | sort -rh | head -15", tags: ["system"], collection: "system", variables: [{ name: "path", default: "." }], createdAt: 0, updatedAt: 0 },
+];
+// ── CRUD operations ──────────────────────────────────────────────────────────
+/** Get all recipes (merged: system + global + project-scoped) */
+export function listRecipes(projectPath) {
+    const global = loadStore(GLOBAL_FILE).recipes;
+    if (!projectPath)
+        return [...global, ...SYSTEM_RECIPES];
+    const project = loadStore(projectFile(projectPath)).recipes;
+    return [...project, ...global, ...SYSTEM_RECIPES]; // project > global > system 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: [] });
+    }
+}

package/dist/search/content-search.js

@@ -0,0 +1,70 @@
+// Smart content search — structured grep/ripgrep with grouping and dedup
+import { spawn } from "child_process";
+import { DEFAULT_EXCLUDE_DIRS, relevanceScore } from "./filters.js";
+function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout?.on("data", (d) => { out += d.toString(); });
+        proc.on("close", () => resolve(out));
+    });
+}
+export async function searchContent(pattern, cwd, options = {}) {
+    const { fileType, maxResults = 30, contextLines = 0 } = options;
+    // Prefer ripgrep, fall back to grep
+    const excludeArgs = DEFAULT_EXCLUDE_DIRS.map(d => `--glob '!${d}'`).join(" ");
+    const typeArg = fileType ? `--type ${fileType}` : "";
+    const contextArg = contextLines > 0 ? `-C ${contextLines}` : "";
+    // Try rg first, fall back to grep
+    const rgCmd = `rg --line-number --no-heading ${contextArg} ${typeArg} ${excludeArgs} '${pattern.replace(/'/g, "'\\''")}' 2>/dev/null | head -500`;
+    const grepCmd = `grep -rn ${contextArg} '${pattern.replace(/'/g, "'\\''")}' . --include='*.ts' --include='*.js' --include='*.py' --include='*.go' --include='*.rs' --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=dist 2>/dev/null | head -500`;
+    let raw = await exec(rgCmd, cwd);
+    if (!raw.trim()) {
+        raw = await exec(grepCmd, cwd);
+    }
+    const lines = raw.split("\n").filter(l => l.trim());
+    const fileMap = new Map();
+    let filteredCount = 0;
+    for (const line of lines) {
+        // Format: path:line:content
+        const match = line.match(/^([^:]+):(\d+):(.*)$/);
+        if (!match)
+            continue;
+        const [, path, lineNum, content] = match;
+        if (DEFAULT_EXCLUDE_DIRS.some(d => path.includes(`/${d}/`))) {
+            filteredCount++;
+            continue;
+        }
+        if (!fileMap.has(path))
+            fileMap.set(path, []);
+        fileMap.get(path).push({
+            line: parseInt(lineNum),
+            content: content.trim(),
+        });
+    }
+    // Sort files by relevance
+    const files = [...fileMap.entries()]
+        .map(([path, matches]) => ({
+        path,
+        matches: matches.slice(0, 5), // max 5 matches per file
+        relevance: relevanceScore(path),
+    }))
+        .sort((a, b) => b.relevance - a.relevance)
+        .slice(0, maxResults);
+    const totalMatches = [...fileMap.values()].reduce((sum, m) => sum + m.length, 0);
+    const filtered = filteredCount > 0 ? [{ count: filteredCount, reason: "excluded directories" }] : [];
+    const rawTokens = Math.ceil(raw.length / 4);
+    const truncated = totalMatches > files.reduce((s, f) => s + f.matches.length, 0);
+    const result = { query: pattern, totalMatches, files, filtered };
+    const resultTokens = Math.ceil(JSON.stringify(result).length / 4);
+    result.tokensSaved = Math.max(0, rawTokens - resultTokens);
+    result.truncated = truncated;
+    // Overflow guard — warn when results are truncated
+    if (totalMatches > maxResults * 3) {
+        result.overflow = {
+            warning: `${totalMatches} total matches across ${fileMap.size} files — showing top ${files.length}`,
+            suggestion: "Try a more specific pattern, add fileType filter, or use -l to list files only",
+        };
+    }
+    return result;
+}

package/dist/search/file-search.js

@@ -0,0 +1,61 @@
+// Smart file search — structured, filtered, token-efficient results
+import { spawn } from "child_process";
+import { DEFAULT_EXCLUDE_DIRS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout?.on("data", (d) => { out += d.toString(); });
+        proc.stderr?.on("data", (d) => { out += d.toString(); });
+        proc.on("close", () => resolve(out));
+    });
+}
+export async function searchFiles(pattern, cwd, options = {}) {
+    const { includeNodeModules = false, maxResults = 50 } = options;
+    // Build find command
+    const excludes = includeNodeModules
+        ? DEFAULT_EXCLUDE_DIRS.filter(d => d !== "node_modules")
+        : DEFAULT_EXCLUDE_DIRS;
+    const excludeArgs = excludes.map(d => `-not -path '*/${d}/*'`).join(" ");
+    const command = `find . -name '${pattern}' -type f ${excludeArgs} 2>/dev/null | head -${maxResults * 3}`;
+    const raw = await exec(command, cwd);
+    const allPaths = raw.split("\n").filter(l => l.trim());
+    // Categorize
+    const source = [];
+    const config = [];
+    const other = [];
+    const filteredCounts = {};
+    for (const path of allPaths) {
+        if (isExcludedDir(path)) {
+            const dir = DEFAULT_EXCLUDE_DIRS.find(d => path.includes(`/${d}/`)) ?? "other";
+            filteredCounts[dir] = (filteredCounts[dir] ?? 0) + 1;
+            continue;
+        }
+        if (isSourceFile(path)) {
+            source.push(path);
+        }
+        else if (path.match(/\.(json|yaml|yml|toml|ini|env)/)) {
+            config.push(path);
+        }
+        else {
+            other.push(path);
+        }
+    }
+    // Sort by relevance
+    source.sort((a, b) => relevanceScore(b) - relevanceScore(a));
+    // Limit results
+    const filtered = Object.entries(filteredCounts).map(([reason, count]) => ({ reason, count }));
+    // Estimate token savings
+    const rawTokens = Math.ceil(raw.length / 4);
+    const result = {
+        query: pattern,
+        total: allPaths.length,
+        source: source.slice(0, maxResults),
+        config: config.slice(0, 10),
+        other: other.slice(0, 10),
+        filtered,
+    };
+    const resultTokens = Math.ceil(JSON.stringify(result).length / 4);
+    result.tokensSaved = Math.max(0, rawTokens - resultTokens);
+    return result;
+}

package/dist/search/filters.js

@@ -0,0 +1,34 @@
+// Smart filters for search results — auto-hide noise, prioritize source files
+export const DEFAULT_EXCLUDE_DIRS = [
+    "node_modules", ".git", "dist", "build", ".next", "__pycache__",
+    "coverage", ".turbo", ".cache", ".output", "vendor", "target",
+];
+export const SOURCE_EXTENSIONS = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".rb",
+    ".sh", ".c", ".cpp", ".h", ".css", ".scss", ".html", ".vue", ".svelte",
+    ".md", ".json", ".yaml", ".yml", ".toml", ".sql", ".graphql",
+]);
+export const CONFIG_EXTENSIONS = new Set([
+    ".json", ".yaml", ".yml", ".toml", ".ini", ".env", ".config.js",
+    ".config.ts", ".config.mjs",
+]);
+export function isSourceFile(path) {
+    const ext = path.match(/\.\w+$/)?.[0] ?? "";
+    return SOURCE_EXTENSIONS.has(ext);
+}
+export function isExcludedDir(path) {
+    return DEFAULT_EXCLUDE_DIRS.some(d => path.includes(`/${d}/`) || path.includes(`/${d}`));
+}
+/** Relevance score: higher = more relevant */
+export function relevanceScore(path) {
+    if (isExcludedDir(path))
+        return 0;
+    const ext = path.match(/\.\w+$/)?.[0] ?? "";
+    if (SOURCE_EXTENSIONS.has(ext))
+        return 10;
+    if (CONFIG_EXTENSIONS.has(ext))
+        return 5;
+    if (path.includes("/test") || path.includes(".test.") || path.includes(".spec."))
+        return 7;
+    return 3;
+}

package/dist/search/index.js

@@ -0,0 +1,5 @@
+// Smart search — unified entry point for file + content search
+export { searchFiles } from "./file-search.js";
+export { searchContent } from "./content-search.js";
+export { DEFAULT_EXCLUDE_DIRS, SOURCE_EXTENSIONS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+export { semanticSearch, findExports, findComponents, findHooks } from "./semantic.js";