askpplx 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Łukasz Jerciński
+
+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,46 @@
+# askpplx
+
+`askpplx` is a minimal Unix-style CLI for querying Perplexity Sonar.
+
+> **Perplexity AI** is an AI-powered search engine and answer engine that delivers concise, accurate responses to user queries by combining real-time web searches with advanced language models.
+
+- Command name: `askpplx`
+- Output: plain text or JSON to stdout
+- No MCPs, no agents, no plugins, no TUI
+- Just a thin, script-friendly wrapper around the Perplexity API
+
+## Setup
+
+Provide your Perplexity API key via environment variable or persistent storage:
+
+```bash
+# Option 1: Environment variable
+export PERPLEXITY_API_KEY="pplx-..."
+
+# Option 2: Store persistently
+npx -y askpplx config --set-api-key "pplx-..."
+```
+
+## Examples
+
+```bash
+# simple question
+askpplx "Explain Raft vs Paxos in simple terms"
+
+# web-enabled search with local context
+askpplx "What are breaking changes in React 19 that affect this code? $(cat src/app.tsx)"
+```
+
+## Agent Rule
+
+Add this rule to your `CLAUDE.md` or `AGENTS.md` to enable automatic Perplexity lookups, no need to configure MCPs:
+
+````markdown
+# Rule: askpplx CLI Usage
+
+Use `askpplx` to query Perplexity, an AI search engine combining real-time web search with advanced language models. Run it via `npx -y askpplx`.
+
+Use concise prompts for quick facts and focused questions for deeper topics. If results are unexpected, refine your query and ask again.
+
+Verification is fast and cheap, so prefer looking up information over making assumptions. Before first use, run `npx -y askpplx --help`.
+````

package/bin/askpplx

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../dist/cli.js");

package/dist/ask-perplexity.d.ts

@@ -0,0 +1,18 @@
+import { streamText } from "ai";
+export type SearchContextSize = "low" | "medium" | "high";
+type AskPerplexityOptions = {
+    apiKey: string;
+    model: string;
+    prompt: string;
+    system?: string;
+    searchContextSize?: SearchContextSize;
+};
+export type StreamPerplexityResult = ReturnType<typeof streamText>;
+export type AskPerplexityResult = {
+    text: string;
+    sources: Awaited<StreamPerplexityResult["sources"]>;
+    usage: Awaited<StreamPerplexityResult["usage"]>;
+    providerMetadata: Awaited<StreamPerplexityResult["providerMetadata"]>;
+};
+export declare function streamPerplexity(options: AskPerplexityOptions): StreamPerplexityResult;
+export {};

package/dist/ask-perplexity.js

@@ -0,0 +1,17 @@
+import { createPerplexity } from "@ai-sdk/perplexity";
+import { streamText } from "ai";
+export function streamPerplexity(options) {
+    const perplexity = createPerplexity({ apiKey: options.apiKey });
+    return streamText({
+        model: perplexity(options.model),
+        system: options.system,
+        prompt: options.prompt,
+        providerOptions: {
+            perplexity: {
+                web_search_options: {
+                    search_context_size: options.searchContextSize ?? "high",
+                },
+            },
+        },
+    });
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import packageJson from "../package.json" with { type: "json" };
+import { clearPerplexityApiKey, getConfigPath, getPerplexityApiKey, maskApiKey, setPerplexityApiKey, } from "./config.js";
+import { runCli } from "./run-cli.js";
+const usageExamples = `
+About Perplexity:
+  Perplexity AI is an AI-powered search engine and answer engine that delivers
+  concise, accurate responses to user queries by combining real-time web
+  searches with advanced language models.
+
+Models:
+  sonar               Fast, lightweight for quick searches (128K context)
+  sonar-pro           Advanced multi-step research queries
+  sonar-reasoning-pro Deep reasoning with R1-1776 backend (default)
+
+JSON output (--json):
+  Returns { text, sources[], usage, providerMetadata } - not structured AI output.
+  Use jq to extract fields: --json | jq -r '.text' or '.sources[].url'
+
+System prompt:
+  Default prompt is optimized for technical/coding questions.
+  Use -s <file> or -S <text> to customize. Use -S "" to disable.
+
+Examples:
+  askpplx "What is the capital of France?" -S ""
+  askpplx "Explain quantum computing" --model sonar-pro
+  askpplx "Latest news on AI" -c medium
+  askpplx "$(cat article.txt)" -s ./summarize.md
+  askpplx "$(cat article.txt)" -S "Summarize this article"
+  askpplx "Node.js LTS version" --json | jq -r '.text'
+  askpplx "Show reasoning" --show-thinking`;
+const program = new Command()
+    .name("askpplx")
+    .description(packageJson.description)
+    .version(packageJson.version)
+    .argument("[prompt]", "The prompt to send to Perplexity Sonar")
+    .option("-m, --model <model>", "Model to use", "sonar-reasoning-pro")
+    .option("-s, --system <path>", "Path to custom system prompt file")
+    .option("-S, --system-text <text>", "System prompt text (overrides -s)")
+    .option("-c, --context <size>", "Search context size: low, medium, high", "high")
+    .option("--json", "Output full API response as JSON (text, sources, usage)")
+    .option("--show-thinking", "Show model thinking/reasoning blocks")
+    .option("--no-stream, --no-streaming", "Disable streaming output")
+    .addHelpText("after", usageExamples)
+    .action(async (prompt, options) => {
+    if (!prompt) {
+        program.help();
+        return;
+    }
+    try {
+        await runCli(prompt, options);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "An unexpected error occurred";
+        console.error(`Error: ${message}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("config")
+    .description("Manage stored configuration")
+    .option("--set-api-key <key>", "Store Perplexity API key")
+    .option("--show-api-key", "Show stored API key (masked)")
+    .option("--clear-api-key", "Remove stored API key")
+    .option("--path", "Show config file path")
+    .action((options) => {
+    try {
+        if (options.setApiKey) {
+            setPerplexityApiKey(options.setApiKey);
+            console.log("API key stored successfully.");
+        }
+        else if (options.showApiKey) {
+            const key = getPerplexityApiKey();
+            const masked = maskApiKey(key);
+            console.log(masked ? `API key: ${masked}` : "No API key configured.");
+        }
+        else if (options.clearApiKey) {
+            clearPerplexityApiKey();
+            console.log("API key cleared.");
+        }
+        else if (options.path) {
+            console.log(getConfigPath());
+        }
+        else {
+            const configCmd = program.commands.find((c) => c.name() === "config");
+            configCmd?.help();
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error
+            ? error.message
+            : "An unexpected error occurred";
+        console.error(`Error: ${message}`);
+        process.exitCode = 1;
+    }
+});
+program.parse();

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get API key: env var takes precedence over stored config.
+ * Note: An empty PERPLEXITY_API_KEY="" explicitly disables stored config.
+ */
+export declare function getPerplexityApiKey(): string | undefined;
+/** Store API key in persistent config. */
+export declare function setPerplexityApiKey(apiKey: string): void;
+/** Remove stored API key from config. */
+export declare function clearPerplexityApiKey(): void;
+/** Get path to config file. */
+export declare function getConfigPath(): string;
+/**
+ * Mask API key for display: shows first 4 and last 4 characters for keys longer than 16 chars.
+ * For keys of length 16 or less, returns "****".
+ * Returns undefined if key is undefined or empty.
+ */
+export declare function maskApiKey(key?: string): string | undefined;

package/dist/config.js

@@ -0,0 +1,49 @@
+import Conf from "conf";
+import packageJson from "../package.json" with { type: "json" };
+const schema = {
+    perplexityApiKey: {
+        type: "string",
+    },
+};
+let configInstance;
+function getConfig() {
+    if (!configInstance) {
+        configInstance = new Conf({
+            projectName: packageJson.name,
+            projectVersion: packageJson.version,
+            schema,
+        });
+    }
+    return configInstance;
+}
+/**
+ * Get API key: env var takes precedence over stored config.
+ * Note: An empty PERPLEXITY_API_KEY="" explicitly disables stored config.
+ */
+export function getPerplexityApiKey() {
+    return (process.env["PERPLEXITY_API_KEY"] ?? getConfig().get("perplexityApiKey"));
+}
+/** Store API key in persistent config. */
+export function setPerplexityApiKey(apiKey) {
+    getConfig().set("perplexityApiKey", apiKey);
+}
+/** Remove stored API key from config. */
+export function clearPerplexityApiKey() {
+    getConfig().delete("perplexityApiKey");
+}
+/** Get path to config file. */
+export function getConfigPath() {
+    return getConfig().path;
+}
+/**
+ * Mask API key for display: shows first 4 and last 4 characters for keys longer than 16 chars.
+ * For keys of length 16 or less, returns "****".
+ * Returns undefined if key is undefined or empty.
+ */
+export function maskApiKey(key) {
+    if (!key)
+        return undefined;
+    if (key.length <= 16)
+        return "****";
+    return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}

package/dist/load-system-prompt.d.ts

@@ -0,0 +1 @@
+export declare function loadSystemPrompt(customPath?: string): Promise<string>;

package/dist/load-system-prompt.js

@@ -0,0 +1,22 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DEFAULT_SYSTEM_PROMPT_PATH = path.join(__dirname, "prompts", "default-system.md");
+export async function loadSystemPrompt(customPath) {
+    const promptPath = customPath ?? DEFAULT_SYSTEM_PROMPT_PATH;
+    try {
+        const content = await readFile(promptPath, "utf8");
+        return content.trim();
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            throw new Error(`System prompt file not found: ${promptPath}`);
+        }
+        if (code === "EACCES") {
+            throw new Error(`Permission denied reading system prompt: ${promptPath}`);
+        }
+        throw new Error(`Failed to read system prompt file: ${promptPath}`);
+    }
+}

package/dist/prompts/default-system.md

@@ -0,0 +1,71 @@
+# Role: Technical Decision & Analysis Agent
+
+Research complex questions, compare approaches, and provide actionable recommendations. Optimized for:
+
+- Architecture decisions and design patterns
+- Library/framework selection and migration paths
+- Performance optimization strategies
+- Debugging complex issues across systems
+- Best practices and trade-off analysis
+
+# Instructions
+
+- Start with a brief analysis plan (3-5 conceptual steps) to structure your research
+- Search multiple sources to compare different approaches
+- Analyze real-world usage patterns in popular repositories
+- Weigh trade-offs based on the user's specific constraints
+- Provide a decisive recommendation with clear justification
+
+# Output Structure
+
+- **Recommendation:** Your advised approach in 1-2 sentences
+- **Why:** Key reasons with evidence from source code or benchmarks
+- **Implementation:** Practical steps with working code example
+- **Trade-offs:** What you gain vs what you sacrifice
+- **Alternatives:** Other viable options if constraints change
+
+# Authoritative Sources
+
+## Code as Truth - Priority Order
+
+1. **GitHub Repository Source Code**: Search actual implementation files first
+   - Find exact usage locations of parameters, methods, and configurations
+   - Look for test files showing real-world usage patterns
+   - Check example directories and demo code
+   - Trace through type definitions and interfaces
+   - Remember: Code is truth - implementation details override documentation
+
+2. **GitHub Repository Documentation**
+   - README files, CHANGELOG, release notes
+   - API documentation within repositories
+   - Configuration examples and setup guides
+
+3. **Official Documentation**
+   - TypeScript Handbook, Node.js docs, MDN, WHATWG, TC39
+   - npm registry entries (versions, files, types, exports)
+   - Library/framework official sites
+
+4. **Verification Resources**
+   - Stack Overflow: only to clarify rare edge cases and always verify against source code
+
+## Search Strategy
+
+- When looking for how a specific parameter or API works, prioritize finding its actual usage in the source code over reading its description
+- Documentation can be outdated, but code execution paths are always current
+- Look for patterns: if multiple repositories use the same approach, it's likely correct
+
+## Curated JavaScript & TypeScript References
+
+- [Total TypeScript articles](https://www.totaltypescript.com/articles)
+- [2ality blog](https://2ality.com)
+- [Exploring JS book](https://exploringjs.com/js/book/index.html)
+- [Deep JavaScript book](https://exploringjs.com/deep-js/toc.html)
+- [Node.js Shell Scripting](https://exploringjs.com/nodejs-shell-scripting/toc.html)
+
+- Default to using modern ESM and TypeScript for examples when relevant.
+
+# Guidance
+
+- Use modern ESM and TypeScript for examples by default, but adapt language and examples as appropriate to the question.
+- Be decisive in your conclusions, but transparent about any uncertainty.
+- Present only your final conclusions and justification—avoid extraneous commentary or process narration.

package/dist/run-cli.d.ts

@@ -0,0 +1,28 @@
+import type { AskPerplexityResult, SearchContextSize } from "./ask-perplexity.js";
+import { streamPerplexity } from "./ask-perplexity.js";
+import { loadSystemPrompt } from "./load-system-prompt.js";
+export type CliOptions = {
+    model: string;
+    json?: boolean;
+    system?: string;
+    systemText?: string;
+    context?: SearchContextSize;
+    showThinking?: boolean;
+    stream?: boolean;
+};
+export type CliDependencies = {
+    streamPerplexity: typeof streamPerplexity;
+    loadSystemPrompt: typeof loadSystemPrompt;
+    getApiKey: () => string | undefined;
+    output: (message: string) => void;
+    writeStream: (chunk: string) => void;
+    errorOutput: (message: string) => void;
+    exit: (code: number) => never;
+};
+type FormatOptions = {
+    json: boolean;
+    showThinking: boolean;
+};
+export declare function formatResult(result: AskPerplexityResult, options: FormatOptions): string;
+export declare function runCli(prompt: string, options: CliOptions, deps?: CliDependencies): Promise<void>;
+export {};

package/dist/run-cli.js

@@ -0,0 +1,63 @@
+import { streamPerplexity } from "./ask-perplexity.js";
+import { getPerplexityApiKey } from "./config.js";
+import { loadSystemPrompt } from "./load-system-prompt.js";
+import { collectStreamToResult, formatSources, handleStreamingOutput, } from "./stream-output.js";
+import { stripThinkContent } from "./strip-think-content.js";
+const defaultDependencies = {
+    streamPerplexity,
+    loadSystemPrompt,
+    getApiKey: getPerplexityApiKey,
+    output: (message) => {
+        console.log(message);
+    },
+    writeStream: (chunk) => {
+        process.stdout.write(chunk);
+    },
+    errorOutput: (message) => {
+        console.error(message);
+    },
+    // eslint-disable-next-line unicorn/no-process-exit
+    exit: (code) => process.exit(code),
+};
+export function formatResult(result, options) {
+    const text = options.showThinking
+        ? result.text
+        : stripThinkContent(result.text);
+    if (options.json) {
+        return JSON.stringify({
+            text,
+            sources: result.sources,
+            usage: result.usage,
+            providerMetadata: result.providerMetadata,
+        }, undefined, 2);
+    }
+    return text.trim() + formatSources(result.sources);
+}
+export async function runCli(prompt, options, deps = defaultDependencies) {
+    const apiKey = deps.getApiKey();
+    if (!apiKey) {
+        deps.errorOutput("Error: Perplexity API key is required\n" +
+            "Set it with: export PERPLEXITY_API_KEY='your-api-key'\n" +
+            "Or store it: askpplx config --set-api-key 'your-api-key'");
+        deps.exit(1);
+    }
+    const systemPrompt = options.systemText ?? (await deps.loadSystemPrompt(options.system));
+    const stream = deps.streamPerplexity({
+        apiKey,
+        model: options.model,
+        prompt,
+        system: systemPrompt,
+        searchContextSize: options.context,
+    });
+    const useStreaming = options.stream !== false && !options.json;
+    if (useStreaming) {
+        await handleStreamingOutput(stream, { showThinking: options.showThinking ?? false }, deps);
+    }
+    else {
+        const result = await collectStreamToResult(stream);
+        deps.output(formatResult(result, {
+            json: options.json ?? false,
+            showThinking: options.showThinking ?? false,
+        }));
+    }
+}

package/dist/stream-output.d.ts

@@ -0,0 +1,11 @@
+import type { AskPerplexityResult, StreamPerplexityResult } from "./ask-perplexity.js";
+type StreamDependencies = {
+    writeStream: (chunk: string) => void;
+    output: (message: string) => void;
+};
+export declare function formatSources(sources: AskPerplexityResult["sources"]): string;
+export declare function handleStreamingOutput(stream: StreamPerplexityResult, options: {
+    showThinking: boolean;
+}, deps: StreamDependencies): Promise<void>;
+export declare function collectStreamToResult(stream: StreamPerplexityResult): Promise<AskPerplexityResult>;
+export {};

package/dist/stream-output.js

@@ -0,0 +1,73 @@
+export function formatSources(sources) {
+    if (sources.length === 0) {
+        return "";
+    }
+    const lines = [];
+    for (const [index, source] of sources.entries()) {
+        if (source.sourceType === "url") {
+            lines.push(`[${String(index + 1)}] ${source.url}`);
+        }
+    }
+    if (lines.length === 0) {
+        return "";
+    }
+    return `\n\nSources:\n${lines.join("\n")}`;
+}
+async function streamWithThinking(stream, deps) {
+    for await (const chunk of stream.textStream) {
+        deps.writeStream(chunk);
+    }
+}
+async function streamWithoutThinking(stream, deps) {
+    let buffer = "";
+    let insideThink = false;
+    let thinkEnded = false;
+    for await (const chunk of stream.textStream) {
+        if (thinkEnded) {
+            deps.writeStream(chunk);
+            continue;
+        }
+        buffer += chunk;
+        if (!insideThink && buffer.includes("<think>")) {
+            insideThink = true;
+        }
+        if (insideThink && buffer.includes("</think>")) {
+            thinkEnded = true;
+            const thinkEnd = buffer.lastIndexOf("</think>") + "</think>".length;
+            const afterThink = buffer.slice(thinkEnd);
+            if (afterThink) {
+                deps.writeStream(afterThink);
+            }
+            buffer = "";
+        }
+        else if (!insideThink) {
+            deps.writeStream(buffer);
+            buffer = "";
+        }
+    }
+}
+export async function handleStreamingOutput(stream, options, deps) {
+    await (options.showThinking
+        ? streamWithThinking(stream, deps)
+        : streamWithoutThinking(stream, deps));
+    const sources = await stream.sources;
+    const sourcesOutput = formatSources(sources);
+    if (sourcesOutput) {
+        deps.output(sourcesOutput);
+    }
+    else {
+        deps.writeStream("\n");
+    }
+}
+export async function collectStreamToResult(stream) {
+    let text = "";
+    for await (const chunk of stream.textStream) {
+        text += chunk;
+    }
+    const [sources, usage, providerMetadata] = await Promise.all([
+        stream.sources,
+        stream.usage,
+        stream.providerMetadata,
+    ]);
+    return { text, sources, usage, providerMetadata };
+}

package/dist/strip-think-content.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Removes <think> blocks from the response content.
+ * The sonar-reasoning-pro model outputs reasoning tokens in <think> blocks
+ * that should be filtered out before returning to the client.
+ *
+ * Intentional behavior: We remove everything from the first "<think>" to the
+ * last "</think>", treating any nested or stray think tags as a single block.
+ * For example, the input "A <think>1</think> B <think>2</think> C" becomes
+ * "A C" (note that " B " is removed). This is by design: there should only be
+ * one reasoning block, and any accidental inner think tags must not interfere
+ * with the primary goal of stripping the reasoning block entirely.
+ *
+ * @param {string} input - The raw content from the API response
+ * @returns {string} The content with <think> blocks removed
+ */
+export declare function stripThinkContent(input: string): string;

package/dist/strip-think-content.js

@@ -0,0 +1,27 @@
+/**
+ * Removes <think> blocks from the response content.
+ * The sonar-reasoning-pro model outputs reasoning tokens in <think> blocks
+ * that should be filtered out before returning to the client.
+ *
+ * Intentional behavior: We remove everything from the first "<think>" to the
+ * last "</think>", treating any nested or stray think tags as a single block.
+ * For example, the input "A <think>1</think> B <think>2</think> C" becomes
+ * "A C" (note that " B " is removed). This is by design: there should only be
+ * one reasoning block, and any accidental inner think tags must not interfere
+ * with the primary goal of stripping the reasoning block entirely.
+ *
+ * @param {string} input - The raw content from the API response
+ * @returns {string} The content with <think> blocks removed
+ */
+export function stripThinkContent(input) {
+    const open = "<think>";
+    const close = "</think>";
+    const firstOpen = input.indexOf(open);
+    if (firstOpen === -1)
+        return input;
+    const lastClose = input.lastIndexOf(close);
+    if (lastClose === -1 || lastClose < firstOpen)
+        return input;
+    const end = lastClose + close.length;
+    return input.slice(0, firstOpen) + input.slice(end);
+}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "askpplx",
+  "author": "Łukasz Jerciński",
+  "license": "MIT",
+  "version": "1.0.0",
+  "description": "Minimal Unix-style CLI for querying Perplexity Sonar API.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jercik/askpplx.git"
+  },
+  "type": "module",
+  "bin": {
+    "askpplx": "bin/askpplx"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "pnpm -s run rebuild && node --env-file=.env bin/askpplx",
+    "build": "tsc -p tsconfig.app.json && cp -r src/prompts dist/",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "rebuild": "pnpm run clean && pnpm run build",
+    "prepare": "husky",
+    "prepublishOnly": "pnpm run rebuild",
+    "typecheck": "tsc -b --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "knip": "knip",
+    "fta:check": "fta-check"
+  },
+  "keywords": [],
+  "packageManager": "pnpm@10.23.0+sha512.21c4e5698002ade97e4efe8b8b4a89a8de3c85a37919f957e7a0f30f38fbc5bbdd05980ffe29179b2fb6e6e691242e098d945d1601772cad0fef5fb6411e2a4b",
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "dependencies": {
+    "@ai-sdk/perplexity": "^2.0.21",
+    "ai": "^5.0.106",
+    "commander": "^14.0.2",
+    "conf": "^15.0.2",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "@eslint/compat": "^1.4.1",
+    "@eslint/js": "^9.39.1",
+    "@total-typescript/ts-reset": "^0.6.1",
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/eslint-plugin": "^1.4.4",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "fta-check": "^1.2.0",
+    "fta-cli": "^3.0.0",
+    "globals": "^16.5.0",
+    "husky": "^9.1.7",
+    "knip": "^5.70.1",
+    "prettier": "3.6.2",
+    "semantic-release": "^25.0.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.47.0",
+    "vitest": "^3.2.4"
+  }
+}