hoolix 0.0.1-beta.19

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hoolix contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,337 @@
+# Hoolix
+
+**Hoolix is your MCP home base.** Turn documentation sites, `llms.txt`, GitHub repositories, templates, and private knowledge sources into secure, source-grounded MCP servers your agents can trust.
+
+[![npm version](https://img.shields.io/npm/v/hoolix?color=blue)](https://www.npmjs.com/package/hoolix)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Build](https://img.shields.io/github/actions/workflow/status/JayLLM/hoolix/release.yml?branch=main)](https://github.com/JayLLM/hoolix/actions)
+[![Docs](https://img.shields.io/badge/docs-Docusaurus-25c2a0?logo=docusaurus)](https://jayllm.github.io/hoolix/)
+
+> Forge docs, repos, and internal knowledge into production-grade MCP servers with a beautiful TUI, a scriptable CLI, and a lightweight GUI.
+
+Hoolix helps developers and teams create high-quality RAG-backed MCP servers from real sources. It keeps every answer grounded with source URLs, supports Streamable HTTP and stdio transports, and gives you the daily tools you need: create, verify, start, connect, reindex, monitor, export, and share.
+
+## Why Hoolix?
+
+Agents are only as useful as the context they can reliably reach. Copy-pasted docs go stale, ad hoc MCP servers are hard to verify, and hosted RAG often adds privacy and cost concerns. Hoolix gives you a local-first, open-source path:
+
+| You need | Hoolix gives you |
+| --- | --- |
+| Fast first run | `hoolix` opens the TUI; `hoolix trial` creates a demo server in one command |
+| Trustworthy retrieval | Source-grounded search, page reads, table of contents, and `verify` health checks |
+| Flexible source models | Single URLs, multi-source definitions, GitHub repos, private docs, templates, and custom source plugins |
+| Real MCP hosting | Authenticated Streamable HTTP plus stdio for local client workflows |
+| Team workflows | Usage stats, audit logs, sanitized exports, and importable bundles |
+| Power-user automation | `--json` across machine-friendly commands, scheduled reindexing, token budgets, and scriptable lifecycle commands |
+
+## Installation
+
+Prebuilt binaries are the recommended path. They are fast, self-contained, and do not require Node, Bun, `tsx`, or source files after installation.
+
+### macOS / Linux
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/JayLLM/Hoolix/main/install.sh | bash
+```
+
+### Windows PowerShell
+
+```powershell
+iex (irm https://raw.githubusercontent.com/JayLLM/Hoolix/main/install.ps1)
+```
+
+The installer verifies the binary and prints PATH guidance if your current terminal needs to be refreshed.
+
+### Try Without Installing
+
+```bash
+npx hoolix trial
+```
+
+This is the easiest way to prove the flow on a new machine or in a demo. The full install is still best for daily use.
+
+## Quick Start
+
+### 1. Open The TUI
+
+```bash
+hoolix
+```
+
+Running `hoolix` with no arguments opens the terminal dashboard. From there you can create servers, start or stop them, verify retrieval quality, copy client configs, launch template flows, and inspect recent logs. It is the friendliest way to learn the product.
+
+If your terminal is non-interactive, Hoolix gracefully falls back to CLI help.
+
+### 2. Create A Trial Server
+
+```bash
+hoolix trial
+hoolix verify hoolix-trial
+hoolix start hoolix-trial
+```
+
+`trial` creates a public demo server from known-good sources, so you can test MCP tools before choosing your own docs.
+
+### 3. Connect Your MCP Client
+
+```bash
+hoolix connect hoolix-trial --client cursor
+```
+
+Supported client targets include Cursor, Claude Desktop, Windsurf, Continue, Cline, Grok Build, and generic JSON output. `connect` creates backups before editing client config files and prints the next step for your client.
+
+### 4. Ask Your Agent
+
+Try:
+
+```text
+Use search_documentation to find installation instructions, then cite the source URL.
+```
+
+Every Hoolix search/read result includes grounding URLs so the agent can show where the answer came from.
+
+## Create Servers
+
+### Single Source
+
+Old syntax remains fully supported:
+
+```bash
+hoolix create "React Docs" --url https://react.dev/llms.txt --yes
+```
+
+Use `--url` for a single documentation URL, `llms.txt`, `llms-full.txt`, GitHub URL, or regular docs page.
+
+### Multi-Source
+
+Use additive `--source` flags when one MCP server should combine multiple knowledge bases:
+
+```bash
+hoolix create "Frontend Stack" \
+  --source docs:https://react.dev/llms.txt \
+  --source github:vercel/next.js \
+  --yes
+```
+
+Each source is stored in the server definition and preserved through reindex, verify, export, import, TUI, and GUI views.
+
+### Template-Backed
+
+Templates are curated starting points for common MCP servers:
+
+```bash
+hoolix templates list
+hoolix templates info terraform-aws-docs
+hoolix create "Terraform AWS" --template terraform-aws-docs --yes
+```
+
+Templates can still accept normal inputs such as `--url`, `--header`, `--cookie`, `--hybrid`, and schedules when the template supports them.
+
+### Private Or Authenticated Sources
+
+```bash
+hoolix create "Private Docs" \
+  --url https://docs.example.com/llms.txt \
+  --header "Authorization: Bearer $DOCS_TOKEN" \
+  --cookie "session=$DOCS_SESSION" \
+  --yes
+```
+
+For private GitHub repositories, set `GITHUB_TOKEN` before creating or reindexing.
+
+## Core Concepts
+
+| Concept | Meaning |
+| --- | --- |
+| Server | A named MCP server with its own slug, index, auth key, audit log, stats, and lifecycle |
+| Source | A piece of knowledge to ingest, such as `docs:<url>`, `github:owner/repo`, `llms:<url>`, `web:<url>`, or `custom:<provider>:<value>` |
+| Server Definition | The validated, portable model that records sources, template backing, auth hints, schedules, and options |
+| Template | An official catalog entry that creates a known-good server shape |
+| Transport | How clients talk to the server: authenticated Streamable HTTP or local stdio |
+| Verification | Hoolix health checks for chunks, samples, grounding, source status, and retrieval quality |
+| Bundle | A `.hoolix.json` export that can be imported elsewhere, optionally stripped of secrets for teams |
+
+## Common Commands
+
+| Command | What it does |
+| --- | --- |
+| `hoolix` | Open the TUI dashboard |
+| `hoolix trial` | Create a one-click demo server |
+| `hoolix create "Name" --url <url>` | Create from one source |
+| `hoolix create "Name" --source docs:<url> --source github:owner/repo` | Create from multiple sources |
+| `hoolix create "Name" --template <id>` | Create from an official template |
+| `hoolix templates list` | Browse official templates |
+| `hoolix list` / `hoolix info <slug>` | Inspect registered servers |
+| `hoolix verify <slug>` | Check source, index, grounding, and retrieval health |
+| `hoolix start <slug>` | Start authenticated Streamable HTTP MCP hosting |
+| `hoolix start <slug> --transport stdio --json` | Print stdio MCP launch config |
+| `hoolix connect <slug> --client cursor` | Wire the server into an MCP client |
+| `hoolix reindex <slug>` | Incrementally refresh sources and rebuild the index |
+| `hoolix reindex <slug> --schedule daily` | Enable scheduled auto-reindex metadata |
+| `hoolix reindex --due --json` | Run servers whose schedule is due |
+| `hoolix stats <slug>` | Show usage analytics and top queries |
+| `hoolix audit <slug>` | Query raw audit entries |
+| `hoolix export <slug> --team --strip-key` | Create a team-safe bundle |
+| `hoolix import --file server.hoolix.json` | Import a bundle |
+| `hoolix gui` | Open the local web dashboard |
+| `hoolix doctor` | Diagnose install, paths, config, runtime, plugins, and source health |
+
+Machine-friendly commands support `--json` so Hoolix works cleanly in scripts and CI.
+
+## MCP Tools
+
+Every hosted Hoolix server exposes:
+
+| Tool | Purpose |
+| --- | --- |
+| `search_documentation` | Search the indexed sources with keyword, hybrid, and optional token/context budgeting |
+| `read_documentation_page` | Read a grounded page or chunk by URL/title |
+| `get_table_of_contents` | Explore indexed structure and source sections |
+
+Tool responses include source URLs. Search tools accept token-aware options such as `maxTokens` and `contextWindowTokens` so clients can request appropriately sized context.
+
+## Transports
+
+### Streamable HTTP
+
+```bash
+hoolix start react-docs
+```
+
+HTTP hosting is authenticated with a per-server bearer key and includes rate limiting, timeouts, and audit logging.
+
+### Stdio
+
+```bash
+hoolix start react-docs --transport stdio --json
+```
+
+Use stdio for clients that prefer local process transports. The JSON output is designed to be copied into client configuration or consumed by automation.
+
+## TUI And GUI
+
+- `hoolix` launches the TUI by default.
+- `hoolix gui` launches a token-protected local dashboard.
+- CLI, TUI, and GUI share the same app services, definitions, catalog, verification, analytics, and server lifecycle logic.
+
+Use the TUI for fast daily work, the CLI for scripts and repeatability, and the GUI for visual management, catalog browsing, stats, and playground testing.
+
+## Reliability And Security
+
+- Per-server auth keys with `hoolix rotate`
+- Tool timeouts and response guards
+- Persistent rate limiting for HTTP hosts
+- Append-only audit logs
+- Usage analytics via `hoolix stats`
+- Incremental reindexing and schedule metadata
+- Private source headers and cookies
+- Team-safe exports with `--strip-key`
+- `doctor` and `verify` health cards for fast diagnosis
+
+## Custom Source Plugins
+
+Hoolix can discover simple source plugin manifests from your data directory or `HOOLIX_SOURCE_PLUGIN_DIR`.
+
+```bash
+hoolix create "Internal Handbook" \
+  --source custom:handbook:getting-started \
+  --yes
+```
+
+Plugins map custom source identifiers to supported source kinds such as docs, web, llms, or GitHub. This keeps Hoolix extensible without forcing every team source into core.
+
+## Examples
+
+```bash
+# TUI-first daily workflow
+hoolix
+
+# One-click first run
+hoolix trial
+hoolix connect hoolix-trial --client cursor
+
+# Single-source docs server
+hoolix create "Astro Docs" --url https://docs.astro.build/llms.txt --yes
+hoolix verify astro-docs
+
+# Multi-source project server
+hoolix create "Company Platform" \
+  --source docs:https://docs.example.com/llms.txt \
+  --source github:example/platform \
+  --source web:https://status.example.com/docs \
+  --yes
+
+# Template-backed server
+hoolix create "Hoolix Docs" --template hoolix-docs --yes
+
+# Private docs
+hoolix create "Private API" \
+  --url https://docs.example.com/private/llms.txt \
+  --header "Authorization: Bearer $DOCS_TOKEN" \
+  --yes
+
+# Scheduled maintenance
+hoolix reindex company-platform --schedule daily --yes
+hoolix reindex --due --json
+
+# Team-safe sharing
+hoolix export company-platform --team --strip-key --file company-platform.hoolix.json
+hoolix import --file company-platform.hoolix.json --slug company-platform-copy --yes
+```
+
+## Future Vision
+
+Hoolix is growing toward the definitive application for MCP operations: official server catalogs, richer team libraries, deeper plugin hooks, managed deployment targets, policy-aware source access, and a shared experience across CLI, TUI, GUI, and hosted workflows.
+
+The north star is simple: when a team asks, "How do we make this knowledge available to agents safely?", the answer should be Hoolix.
+
+## Development
+
+```bash
+bun install
+
+# Run from source
+bun run dev
+
+# Type check
+npm run typecheck
+
+# Tests
+npm test
+npm run test:e2e
+
+# Build native binary
+bun run build:binary
+
+# Documentation site
+cd docs
+npm install
+npm start
+```
+
+See [AGENTS.md](./AGENTS.md) for architecture rules, contribution expectations, testing guidance, and documentation requirements.
+
+## Limitations
+
+- Hoolix is local-first today. Production public hosting is expected to sit behind your reverse proxy or future hosted deployment path.
+- Hybrid semantic search is optional and lazy-loaded. The default index stays fast and lightweight.
+- Heavily protected sites may require `--header`, `--cookie`, direct `llms.txt`, or GitHub token access.
+- Template and plugin ecosystems are intentionally conservative while the catalog matures.
+
+## Contributing
+
+Contributions are welcome. Please open an issue for substantial changes, keep PRs focused, run tests, and update documentation alongside behavior changes.
+
+## Releasing
+
+Release automation uses `release-it` and GitHub Actions. See [docs/RELEASING.md](./docs/RELEASING.md) for the release checklist and binary publishing workflow.
+
+## License
+
+MIT © Hoolix contributors
+
+---
+
+**Links**: [GitHub](https://github.com/JayLLM/Hoolix) · [Issues](https://github.com/JayLLM/Hoolix/issues) · [Releases](https://github.com/JayLLM/Hoolix/releases)
+
+Made for developers who want agents to find the right paragraph, cite the right URL, and get back to work.

package/STABILITY.md

@@ -0,0 +1,109 @@
+# Hoolix Stability & Versioning Promises
+
+**Current stable version: 1.0.0 (released 2026-06-04)**
+
+This document describes what is stable, what may change, and the versioning policy for Hoolix v1.0 and beyond.
+
+## Installation (recommended)
+
+```bash
+npm install -g hoolix        # recommended — provenance-verified
+```
+
+Standalone binary (Linux/macOS):
+```bash
+curl -fsSL https://raw.githubusercontent.com/JayLLM/hoolix/main/install.sh | bash
+```
+
+Standalone binary (Windows):
+```powershell
+iwr -useb https://raw.githubusercontent.com/JayLLM/hoolix/main/install.ps1 | iex
+```
+
+---
+
+## Versioning (Semantic Versioning)
+
+Hoolix follows [Semantic Versioning](https://semver.org) `MAJOR.MINOR.PATCH`:
+
+| Change type | Version bump |
+|---|---|
+| Breaking change to stable CLI or data format | **MAJOR** |
+| New command, new template, new flag | **MINOR** |
+| Bug fix, performance, or non-breaking behaviour | **PATCH** |
+
+Pre-releases (`0.0.1-beta.*`) carry **no stability guarantees**. Once v1.0.0 ships, the promises below apply.
+
+---
+
+## What is stable in v1.0
+
+### CLI commands and flags
+All commands listed in `hoolix --help` are considered **stable**. Their positional arguments, named flags, and exit codes will not change in a breaking way within a MAJOR version.
+
+| Command | Stable? | Notes |
+|---|---|---|
+| `hoolix create / install` | ✅ | Positional syntax and flag names locked |
+| `hoolix list / info / delete` | ✅ | Output columns stable in human mode; `--json` schema stable |
+| `hoolix start / stop` | ✅ | `--proxy` flag and HTTP config format stable |
+| `hoolix connect` | ✅ | Per-client config format follows official MCP client schemas |
+| `hoolix secrets *` | ✅ | |
+| `hoolix export / import` | ✅ | Bundle format `version: 2` stable |
+| `hoolix bundle export/import` | ✅ | Multi-server bundle format `version: 1` stable |
+| `hoolix templates *` | ✅ | |
+| `hoolix completion` | ✅ | Script output may improve; sourcing pattern unchanged |
+| `hoolix doctor` | ✅ | Check names stable; JSON keys stable |
+| `hoolix stats / audit` | ✅ | |
+| `hoolix rotate` | ✅ | |
+| `hoolix gui` | ✅ | Web dashboard local-only; no auth changes without notice |
+| `hoolix update / uninstall` | ✅ | |
+| `hoolix trial` | ✅ | Template used may change; flags stable |
+
+### JSON output (`--json`)
+When `--json` is passed, the top-level object shape is **stable**. New keys may be added (non-breaking). Keys will not be removed or renamed within a MAJOR version.
+
+### Data files on disk
+| File | Path | Stability |
+|---|---|---|
+| `metadata.json` | `~/.local/share/hoolix/servers/<slug>/` | Stable — new keys may be added |
+| `credentials.json` | Same directory, mode 0600 | Stable |
+| `.runtime.json` | Same directory | Stable (new keys may be added) |
+| `audit.log` | Same directory | Newline-delimited JSON; schema stable |
+| `chunks.json` | `data/` subdirectory | Stable |
+| Bundle format | `.hoolix.json` | `version: 2` (single) and `version: 1` (multi) stable |
+
+### Template IDs
+Official template IDs (e.g. `filesystem`, `github-api`, `postgres`) will not be removed or renamed in a MINOR bump. New templates are always additive.
+
+---
+
+## What may change (no stability promise)
+
+| Area | Status |
+|---|---|
+| TUI layout and key bindings | **Unstable** — may change in any MINOR |
+| Internal `__internal-host` / `__internal-proxy` flags | **Internal** — never call directly |
+| Web GUI (`hoolix gui`) API routes | **Unstable** until v1.1 |
+| Community template format | Stable schema; directory path may change before v1.0 |
+| SSE streaming in proxy mode | Phase 1 only; full SSE streaming is planned for a future MINOR |
+| `hoolix verify` scoring rubric | May improve; exact scores may change |
+
+---
+
+## Upgrade policy
+
+- **PATCH** → safe to upgrade immediately; no action needed.
+- **MINOR** → safe to upgrade; new features available. Read the CHANGELOG.
+- **MAJOR** → migration guide published with the release. Existing data files are migrated automatically where possible; breaking CLI changes are listed explicitly.
+
+---
+
+## Long-term support (LTS)
+
+v1.x will receive security fixes for a minimum of **24 months** after release. v2.0 will be announced with at least 6 months notice.
+
+---
+
+## Filing stability issues
+
+If you find a behaviour that violates these promises (a command flag removed, a JSON key renamed, a data file broken), please [open an issue](https://github.com/JayLLM/hoolix/issues) with the label `stability`.

package/bin/hoolix.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+/**
+ * Hoolix CLI — npm global package entry point.
+ *
+ * Production path (dist/index.js exists after `npm install -g hoolix`):
+ *   Loads compiled JS via dynamic import *in the same process*.
+ *   This gives correct signal handling (Ctrl+C in TUI), faster startup,
+ *   and avoids the subprocess overhead of the old spawnSync approach.
+ *
+ * Development path (dist/ absent, src/ present):
+ *   Falls back to tsx via spawnSync for TypeScript source execution.
+ *
+ * Note: this file is intentionally plain JS (not TS) so it runs without
+ * any compilation step. It uses top-level await which requires Node ≥ 14.8
+ * and ESM ("type":"module" in package.json).
+ */
+
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const distEntry = join(__dirname, '..', 'dist', 'index.js');
+const srcEntry  = join(__dirname, '..', 'src', 'index.ts');
+
+if (existsSync(distEntry)) {
+  // ── Production / npm global install ──────────────────────────────────────
+  // Import compiled JS directly into this process. process.argv is already set
+  // correctly (node bins/hoolix.js [...args]), so src/index.ts reads args normally.
+  // Signals (SIGTERM, SIGINT/Ctrl+C, etc.) are handled by src/index.ts directly
+  // without needing to propagate through a subprocess.
+  await import(distEntry);
+} else {
+  // ── Development fallback ──────────────────────────────────────────────────
+  // dist/ not built — use tsx to run TypeScript source directly.
+  const { spawnSync } = await import('node:child_process');
+
+  const tsx = join(__dirname, '..', 'node_modules', '.bin', 'tsx');
+  if (!existsSync(tsx)) {
+    console.error('[hoolix] Development mode requires tsx. Run: npm install');
+    process.exit(1);
+  }
+
+  const { status } = spawnSync(tsx, [srcEntry, ...process.argv.slice(2)], {
+    stdio:  'inherit',
+    env:    process.env,
+  });
+  process.exit(status ?? 1);
+}

package/bin/mcp-portal.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+console.warn('Deprecated: Please use the `hoolix` binary instead of `hoolix`.');
+try {
+  // Try to exec the new binary if present
+  const { spawnSync } = require('child_process');
+  const result = spawnSync('hoolix', process.argv.slice(2), { stdio: 'inherit' });
+  process.exit(result.status ?? 1);
+} catch (e) {
+  console.error('`hoolix` binary not found in PATH. Install using the installer scripts or run `npm run build` and use the dist binary.');
+  process.exit(1);
+}

package/bin/postinstall.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * Postinstall hint — shown once after `npm install -g hoolix`.
+ *
+ * Intentionally plain CJS with no imports so it runs on any Node ≥ 14 without
+ * compilation or ESM resolution. The script always exits 0.
+ *
+ * Skips output when:
+ *   - Running in CI (CI=1)
+ *   - Explicitly suppressed (HOOLIX_NO_POSTINSTALL=1)
+ *   - stdout is not a TTY (piped / scripted install)
+ *   - The install looks like a local dev install (no npm_config_global set
+ *     and node_modules/.bin/tsx exists next to us, indicating a dev checkout)
+ */
+
+'use strict';
+
+// Always exit 0 — postinstall must never fail or block the install.
+process.on('uncaughtException', () => process.exit(0));
+
+(function run() {
+  // Skip in CI or when explicitly suppressed
+  if (process.env.CI || process.env.HOOLIX_NO_POSTINSTALL === '1') return;
+
+  // Skip when output is not a terminal (e.g. npm install piped into a script)
+  if (!process.stdout.isTTY) return;
+
+  // Skip if this looks like a dev checkout: check for the presence of src/
+  // (i.e. we're running postinstall because someone ran `npm install` in the repo)
+  const path = require('node:path');
+  const fs   = require('node:fs');
+  const dir  = path.resolve(__dirname, '..');
+  if (fs.existsSync(path.join(dir, 'src', 'index.ts'))) return;
+
+  const c = {
+    cyan:  '\x1b[36m',
+    green: '\x1b[32m',
+    yellow:'\x1b[33m',
+    bold:  '\x1b[1m',
+    dim:   '\x1b[2m',
+    reset: '\x1b[0m',
+  };
+
+  process.stdout.write([
+    '',
+    `  ${c.cyan}${c.bold}◆ hoolix installed!${c.reset}`,
+    '',
+    `  ${c.green}✓${c.reset} Run ${c.cyan}hoolix doctor${c.reset} to verify your installation.`,
+    `  ${c.green}✓${c.reset} Run ${c.cyan}hoolix templates list${c.reset} to browse 14 official templates.`,
+    `  ${c.green}✓${c.reset} Run ${c.cyan}hoolix install filesystem /path/to/project --yes${c.reset} to get started.`,
+    '',
+    `  ${c.yellow}Shell completions:${c.reset}`,
+    `  ${c.dim}bash:${c.reset}        eval "$(hoolix completion bash)"`,
+    `  ${c.dim}zsh:${c.reset}         eval "$(hoolix completion zsh)"`,
+    `  ${c.dim}fish:${c.reset}        hoolix completion fish | source`,
+    `  ${c.dim}powershell:${c.reset}  hoolix completion powershell | Invoke-Expression`,
+    '',
+    `  ${c.dim}Full docs: https://github.com/JayLLM/hoolix${c.reset}`,
+    '',
+  ].join('\n'));
+}());