@hasna/terminal 0.1.4 → 0.2.0

package/src/providers/cerebras.ts

@@ -0,0 +1,108 @@
+// Cerebras provider — uses OpenAI-compatible API
+// Default for open-source users. Fast inference on Llama models.
+
+import type { LLMProvider, ProviderOptions, StreamCallbacks } from "./base.js";
+
+const CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
+const DEFAULT_MODEL = "llama-4-scout-17b-16e";
+
+export class CerebrasProvider implements LLMProvider {
+  readonly name = "cerebras";
+  private apiKey: string;
+
+  constructor() {
+    this.apiKey = process.env.CEREBRAS_API_KEY ?? "";
+  }
+
+  isAvailable(): boolean {
+    return !!process.env.CEREBRAS_API_KEY;
+  }
+
+  async complete(prompt: string, options: ProviderOptions): Promise<string> {
+    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()) 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(`${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) 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

@@ -0,0 +1,60 @@
+// Provider auto-detection and management
+
+import type { LLMProvider, ProviderConfig } from "./base.js";
+import { DEFAULT_PROVIDER_CONFIG } from "./base.js";
+import { AnthropicProvider } from "./anthropic.js";
+import { CerebrasProvider } from "./cerebras.js";
+
+export type { LLMProvider, ProviderOptions, StreamCallbacks, ProviderConfig } from "./base.js";
+export { DEFAULT_PROVIDER_CONFIG } from "./base.js";
+
+let _provider: LLMProvider | null = null;
+
+/** Get the active LLM provider. Auto-detects based on available API keys. */
+export function getProvider(config?: ProviderConfig): LLMProvider {
+  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: ProviderConfig): LLMProvider {
+  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;
+  }
+
+  // auto: prefer Cerebras (open-source friendly), fall back to Anthropic
+  const cerebras = new CerebrasProvider();
+  if (cerebras.isAvailable()) return cerebras;
+
+  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)"
+  );
+}
+
+/** List available providers (for onboarding UI). */
+export function availableProviders(): { name: string; available: boolean }[] {
+  return [
+    { name: "cerebras", available: new CerebrasProvider().isAvailable() },
+    { name: "anthropic", available: new AnthropicProvider().isAvailable() },
+  ];
+}

package/src/providers/providers.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "bun:test";
+import { availableProviders, resetProvider } from "./index.js";
+
+describe("providers", () => {
+  it("lists available providers", () => {
+    const providers = availableProviders();
+    expect(providers.length).toBe(2);
+    expect(providers[0].name).toBe("cerebras");
+    expect(providers[1].name).toBe("anthropic");
+  });
+
+  it("resetProvider clears cache", () => {
+    // Should not throw
+    resetProvider();
+  });
+});

package/src/recipes/model.ts

@@ -0,0 +1,55 @@
+// Recipes data model — reusable command templates with collections and projects
+
+export interface RecipeVariable {
+  name: string;
+  description?: string;
+  default?: string;
+  required?: boolean;
+}
+
+export interface Recipe {
+  id: string;
+  name: string;
+  description?: string;
+  command: string;
+  tags: string[];
+  collection?: string;
+  project?: string;  // project path — if set, recipe is project-scoped
+  variables: RecipeVariable[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface Collection {
+  id: string;
+  name: string;
+  description?: string;
+  project?: string;
+  createdAt: number;
+}
+
+export interface RecipeStore {
+  recipes: Recipe[];
+  collections: Collection[];
+}
+
+/** Generate a short random ID */
+export function genId(): string {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+/** Substitute variables in a command template */
+export function substituteVariables(command: string, vars: Record<string, string>): string {
+  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: string): string[] {
+  const matches = command.match(/\{(\w+)\}/g);
+  if (!matches) return [];
+  return [...new Set(matches.map(m => m.slice(1, -1)))];
+}

package/src/recipes/recipes.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "bun:test";
+import { genId, substituteVariables, extractVariables } from "./model.js";
+
+describe("genId", () => {
+  it("generates unique ids", () => {
+    const a = genId();
+    const b = genId();
+    expect(a).not.toBe(b);
+    expect(a.length).toBe(8);
+  });
+});
+
+describe("substituteVariables", () => {
+  it("replaces {var} placeholders", () => {
+    expect(substituteVariables("kill -9 {pid}", { pid: "1234" })).toBe("kill -9 1234");
+  });
+
+  it("replaces multiple variables", () => {
+    expect(substituteVariables("curl {host}:{port}", { host: "localhost", port: "3000" }))
+      .toBe("curl localhost:3000");
+  });
+
+  it("replaces all occurrences of same variable", () => {
+    expect(substituteVariables("{x} and {x}", { x: "y" })).toBe("y and y");
+  });
+
+  it("leaves unmatched vars alone", () => {
+    expect(substituteVariables("{a} {b}", { a: "1" })).toBe("1 {b}");
+  });
+});
+
+describe("extractVariables", () => {
+  it("extracts variable names from command", () => {
+    expect(extractVariables("lsof -i :{port} -t | xargs kill")).toEqual(["port"]);
+  });
+
+  it("deduplicates", () => {
+    expect(extractVariables("{x} {x} {y}")).toEqual(["x", "y"]);
+  });
+
+  it("returns empty for no variables", () => {
+    expect(extractVariables("ls -la")).toEqual([]);
+  });
+});

package/src/recipes/storage.ts

@@ -0,0 +1,142 @@
+// 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 type { Recipe, Collection, RecipeStore } from "./model.js";
+import { genId, extractVariables } from "./model.js";
+
+const GLOBAL_DIR = join(homedir(), ".terminal");
+const GLOBAL_FILE = join(GLOBAL_DIR, "recipes.json");
+
+function projectFile(projectPath: string): string {
+  return join(projectPath, ".terminal", "recipes.json");
+}
+
+function loadStore(filePath: string): RecipeStore {
+  if (!existsSync(filePath)) return { recipes: [], collections: [] };
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return { recipes: [], collections: [] };
+  }
+}
+
+function saveStore(filePath: string, store: RecipeStore): void {
+  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?: string): Recipe[] {
+  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: string, projectPath?: string): Recipe[] {
+  return listRecipes(projectPath).filter(r => r.collection === collection);
+}
+
+/** Get a recipe by name */
+export function getRecipe(name: string, projectPath?: string): Recipe | null {
+  return listRecipes(projectPath).find(r => r.name === name) ?? null;
+}
+
+/** Create a recipe */
+export function createRecipe(opts: {
+  name: string;
+  command: string;
+  description?: string;
+  tags?: string[];
+  collection?: string;
+  project?: string;
+  variables?: { name: string; default?: string; required?: boolean }[];
+}): Recipe {
+  const filePath = opts.project ? projectFile(opts.project) : GLOBAL_FILE;
+  const store = loadStore(filePath);
+
+  // 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: 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: string, projectPath?: string): boolean {
+  // 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?: string): Collection[] {
+  const global = loadStore(GLOBAL_FILE).collections;
+  if (!projectPath) return global;
+  const project = loadStore(projectFile(projectPath)).collections;
+  return [...project, ...global];
+}
+
+export function createCollection(opts: { name: string; description?: string; project?: string }): Collection {
+  const filePath = opts.project ? projectFile(opts.project) : GLOBAL_FILE;
+  const store = loadStore(filePath);
+
+  const collection: 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: string): void {
+  const file = projectFile(projectPath);
+  if (!existsSync(file)) {
+    saveStore(file, { recipes: [], collections: [] });
+  }
+}

package/src/search/content-search.ts

@@ -0,0 +1,97 @@
+// Smart content search — structured grep/ripgrep with grouping and dedup
+
+import { spawn } from "child_process";
+import { DEFAULT_EXCLUDE_DIRS, relevanceScore } from "./filters.js";
+
+export interface ContentMatch {
+  line: number;
+  content: string;
+  context?: string[];
+}
+
+export interface ContentFileMatch {
+  path: string;
+  matches: ContentMatch[];
+  relevance: number;
+}
+
+export interface ContentSearchResult {
+  query: string;
+  totalMatches: number;
+  files: ContentFileMatch[];
+  filtered: { count: number; reason: string }[];
+  tokensSaved?: number;
+}
+
+function exec(command: string, cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    proc.stdout?.on("data", (d: Buffer) => { out += d.toString(); });
+    proc.on("close", () => resolve(out));
+  });
+}
+
+export async function searchContent(
+  pattern: string,
+  cwd: string,
+  options: { fileType?: string; maxResults?: number; contextLines?: number } = {}
+): Promise<ContentSearchResult> {
+  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<string, ContentMatch[]>();
+  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: ContentFileMatch[] = [...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 result: ContentSearchResult = { query: pattern, totalMatches, files, filtered };
+  const resultTokens = Math.ceil(JSON.stringify(result).length / 4);
+  result.tokensSaved = Math.max(0, rawTokens - resultTokens);
+
+  return result;
+}

package/src/search/file-search.ts

@@ -0,0 +1,86 @@
+// Smart file search — structured, filtered, token-efficient results
+
+import { spawn } from "child_process";
+import { DEFAULT_EXCLUDE_DIRS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+
+export interface FileSearchResult {
+  query: string;
+  total: number;
+  source: string[];
+  config: string[];
+  other: string[];
+  filtered: { count: number; reason: string }[];
+  tokensSaved?: number;
+}
+
+function exec(command: string, cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    proc.stdout?.on("data", (d: Buffer) => { out += d.toString(); });
+    proc.stderr?.on("data", (d: Buffer) => { out += d.toString(); });
+    proc.on("close", () => resolve(out));
+  });
+}
+
+export async function searchFiles(
+  pattern: string,
+  cwd: string,
+  options: { includeNodeModules?: boolean; maxResults?: number } = {}
+): Promise<FileSearchResult> {
+  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: string[] = [];
+  const config: string[] = [];
+  const other: string[] = [];
+  const filteredCounts: Record<string, number> = {};
+
+  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: FileSearchResult = {
+    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/src/search/filters.ts

@@ -0,0 +1,36 @@
+// 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: string): boolean {
+  const ext = path.match(/\.\w+$/)?.[0] ?? "";
+  return SOURCE_EXTENSIONS.has(ext);
+}
+
+export function isExcludedDir(path: string): boolean {
+  return DEFAULT_EXCLUDE_DIRS.some(d => path.includes(`/${d}/`) || path.includes(`/${d}`));
+}
+
+/** Relevance score: higher = more relevant */
+export function relevanceScore(path: string): number {
+  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/src/search/index.ts

@@ -0,0 +1,7 @@
+// Smart search — unified entry point for file + content search
+
+export { searchFiles } from "./file-search.js";
+export type { FileSearchResult } from "./file-search.js";
+export { searchContent } from "./content-search.js";
+export type { ContentSearchResult, ContentFileMatch, ContentMatch } from "./content-search.js";
+export { DEFAULT_EXCLUDE_DIRS, SOURCE_EXTENSIONS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";

package/src/search/search.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "bun:test";
+import { isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+
+describe("filters", () => {
+  it("identifies source files", () => {
+    expect(isSourceFile("src/app.ts")).toBe(true);
+    expect(isSourceFile("index.tsx")).toBe(true);
+    expect(isSourceFile("main.py")).toBe(true);
+    expect(isSourceFile("image.png")).toBe(false);
+    expect(isSourceFile("binary")).toBe(false);
+  });
+
+  it("identifies excluded directories", () => {
+    expect(isExcludedDir("./node_modules/foo/bar.js")).toBe(true);
+    expect(isExcludedDir("./dist/index.js")).toBe(true);
+    expect(isExcludedDir("./.git/config")).toBe(true);
+    expect(isExcludedDir("./src/lib/utils.ts")).toBe(false);
+  });
+
+  it("scores source files highest", () => {
+    expect(relevanceScore("src/app.ts")).toBe(10);
+    expect(relevanceScore("./node_modules/foo.js")).toBe(0);
+    expect(relevanceScore("binary")).toBe(3);
+  });
+});