@praneeth_54/agentdoctor 0.1.0-beta

package/dist/reporters/json/report.js

@@ -0,0 +1,84 @@
+import { sanitizeForOutput } from "../../utils/path.js";
+/**
+ * Stable machine-readable scan output. No decorative terminal formatting.
+ */
+export function renderJsonReport(result) {
+    const payload = {
+        version: result.version,
+        repository: {
+            root: sanitizeForOutput(result.repository.root),
+            languages: result.repository.languages,
+            primaryLanguage: result.repository.primaryLanguage,
+            frameworks: result.repository.frameworks,
+            primaryFramework: result.repository.primaryFramework,
+            packageManagers: result.repository.packageManagers,
+            primaryPackageManager: result.repository.primaryPackageManager,
+            monorepo: result.repository.monorepo,
+            filesScanned: result.repository.filesScanned,
+        },
+        agents: result.agents.map((agent) => ({
+            id: agent.id,
+            displayName: agent.displayName,
+            detected: agent.detected,
+            configured: agent.configured,
+            status: agent.status,
+            summary: sanitizeForOutput(agent.summary),
+            configFiles: agent.configFiles.map((file) => ({
+                relativePath: sanitizeForOutput(file.relativePath),
+                kind: file.kind,
+                sizeBytes: file.sizeBytes,
+                empty: file.empty,
+                readable: file.readable,
+                legacy: file.legacy,
+                scope: file.scope,
+                ...(file.parseError !== undefined
+                    ? { parseError: sanitizeForOutput(file.parseError) }
+                    : {}),
+            })),
+            configPaths: agent.configPaths.map(sanitizeForOutput),
+            diagnostics: agent.diagnostics.map((diagnostic) => ({
+                code: diagnostic.code,
+                severity: diagnostic.severity,
+                message: sanitizeForOutput(diagnostic.message),
+                ...(diagnostic.file !== undefined ? { file: sanitizeForOutput(diagnostic.file) } : {}),
+            })),
+            metadata: agent.metadata,
+        })),
+        findings: result.findings.map((finding) => ({
+            id: finding.id,
+            ruleId: finding.ruleId,
+            category: finding.category,
+            severity: finding.severity,
+            title: sanitizeForOutput(finding.title),
+            message: sanitizeForOutput(finding.message),
+            whyItMatters: sanitizeForOutput(finding.whyItMatters),
+            ...(finding.recommendation !== undefined
+                ? { recommendation: sanitizeForOutput(finding.recommendation) }
+                : {}),
+            affectedAgents: finding.affectedAgents,
+            ...(finding.evidence !== undefined
+                ? {
+                    evidence: {
+                        ...(finding.evidence.path !== undefined
+                            ? { path: sanitizeForOutput(finding.evidence.path) }
+                            : {}),
+                        ...(finding.evidence.line !== undefined ? { line: finding.evidence.line } : {}),
+                        ...(finding.evidence.detail !== undefined
+                            ? { detail: sanitizeForOutput(finding.evidence.detail) }
+                            : {}),
+                    },
+                }
+                : {}),
+            fixability: finding.fixability,
+        })),
+        summary: result.summary,
+        scoringAvailable: result.scoringAvailable,
+        scores: result.scores,
+        timing: result.timing,
+        diagnostics: {
+            warnings: result.diagnostics.warnings.map(sanitizeForOutput),
+            errors: result.diagnostics.errors.map(sanitizeForOutput),
+        },
+    };
+    return `${JSON.stringify(payload, null, 2)}\n`;
+}

package/dist/reporters/terminal/report.d.ts

@@ -0,0 +1,8 @@
+import type { ScanResult } from "../../types/index.js";
+export interface TerminalReportOptions {
+    verbose?: boolean;
+}
+/**
+ * Terminal report: agents and actionable findings.
+ */
+export declare function renderTerminalReport(result: ScanResult, options?: TerminalReportOptions): string;

package/dist/reporters/terminal/report.js

@@ -0,0 +1,147 @@
+import { PACKAGE_VERSION } from "../../constants.js";
+import { AGENT_DISPLAY_NAMES } from "../../constants.js";
+import { formatFramework } from "../../detectors/framework.js";
+import { formatLanguage } from "../../detectors/language.js";
+import { formatMonorepo } from "../../detectors/monorepo.js";
+import { formatPackageManager } from "../../detectors/package-manager.js";
+import { colors, symbolFail, symbolInfo, symbolOk, symbolWarn } from "../../utils/colors.js";
+import { sanitizeTerminalText } from "../../security/redaction.js";
+const DEFAULT_FINDING_LIMIT = 12;
+function groupFindings(findings) {
+    return {
+        critical: findings.filter((f) => f.severity === "critical"),
+        warning: findings.filter((f) => f.severity === "warning"),
+        info: findings.filter((f) => f.severity === "info"),
+    };
+}
+function agentGlyph(configured, detected) {
+    if (configured) {
+        return symbolOk();
+    }
+    if (detected) {
+        return symbolWarn();
+    }
+    return colors.dim("–");
+}
+function formatAgents(agents) {
+    return agents.map((id) => AGENT_DISPLAY_NAMES[id] ?? id).join(", ");
+}
+function renderFindingBlock(finding, verbose) {
+    const lines = [];
+    const icon = finding.severity === "critical"
+        ? symbolFail()
+        : finding.severity === "warning"
+            ? symbolWarn()
+            : symbolInfo();
+    lines.push(`  ${icon} ${sanitizeTerminalText(finding.title)}`);
+    if (finding.evidence?.path) {
+        lines.push(colors.dim(`    ${sanitizeTerminalText(finding.evidence.path)}`));
+    }
+    if (finding.affectedAgents.length > 0) {
+        lines.push(colors.dim(`    Affected: ${formatAgents(finding.affectedAgents)}`));
+    }
+    lines.push(`    ${sanitizeTerminalText(finding.message)}`);
+    if (verbose) {
+        lines.push(colors.dim(`    Why: ${sanitizeTerminalText(finding.whyItMatters)}`));
+    }
+    if (finding.recommendation) {
+        lines.push(`    Fix: ${sanitizeTerminalText(finding.recommendation)}`);
+    }
+    lines.push("");
+    return lines;
+}
+/**
+ * Terminal report: agents and actionable findings.
+ */
+export function renderTerminalReport(result, options = {}) {
+    const lines = [];
+    const verbose = options.verbose ?? false;
+    lines.push("");
+    lines.push(colors.bold(`🩺 AgentDoctor`) + colors.dim(` v${PACKAGE_VERSION}`));
+    lines.push("");
+    lines.push(colors.dim("Scanning repository..."));
+    lines.push("");
+    lines.push(colors.bold("Repository"));
+    lines.push(`  Framework: ${sanitizeTerminalText(formatFramework(result.repository.primaryFramework))}`);
+    lines.push(`  Language: ${sanitizeTerminalText(formatLanguage(result.repository.primaryLanguage))}`);
+    lines.push(`  Package manager: ${sanitizeTerminalText(formatPackageManager(result.repository.primaryPackageManager))}`);
+    if (result.repository.monorepo !== "none") {
+        lines.push(`  Monorepo: ${sanitizeTerminalText(formatMonorepo(result.repository.monorepo))}`);
+    }
+    lines.push(`  Files scanned: ${result.repository.filesScanned}`);
+    lines.push("");
+    lines.push(colors.bold("AI Coding Agents"));
+    lines.push("");
+    for (const agent of result.agents) {
+        const glyph = agentGlyph(agent.configured, agent.detected);
+        const status = agent.configured ? "configured" : agent.detected ? "detected" : "not configured";
+        lines.push(`${glyph} ${pad(sanitizeTerminalText(agent.displayName), 12)} ${colors.dim(status)}`);
+        if (verbose && agent.configured) {
+            lines.push(colors.dim(`    ${sanitizeTerminalText(agent.summary)}`));
+            for (const configPath of agent.configPaths) {
+                lines.push(colors.dim(`    · ${sanitizeTerminalText(configPath)}`));
+            }
+        }
+    }
+    lines.push("");
+    const grouped = groupFindings(result.findings);
+    const total = result.summary.total;
+    lines.push(colors.bold("Findings"));
+    lines.push("");
+    if (total === 0) {
+        lines.push(`  ${symbolOk()} No findings`);
+        lines.push("");
+    }
+    else {
+        let shown = 0;
+        const limit = verbose ? Number.POSITIVE_INFINITY : DEFAULT_FINDING_LIMIT;
+        for (const severity of ["critical", "warning", "info"]) {
+            const list = grouped[severity];
+            if (list.length === 0) {
+                continue;
+            }
+            const header = severity === "critical"
+                ? colors.red(colors.bold("CRITICAL"))
+                : severity === "warning"
+                    ? colors.yellow(colors.bold("WARNING"))
+                    : colors.cyan(colors.bold("INFO"));
+            lines.push(header);
+            lines.push("");
+            for (const finding of list) {
+                if (shown >= limit) {
+                    break;
+                }
+                lines.push(...renderFindingBlock(finding, verbose));
+                shown += 1;
+            }
+            if (shown >= limit) {
+                break;
+            }
+        }
+        if (total > shown) {
+            lines.push(colors.dim(`  … and ${total - shown} more. Re-run with --verbose to see additional detail.`));
+            lines.push("");
+        }
+    }
+    lines.push(colors.bold("Summary"));
+    lines.push("");
+    lines.push(`  ${result.summary.critical} critical`);
+    lines.push(`  ${result.summary.warning} warning`);
+    lines.push(`  ${result.summary.info} info`);
+    lines.push("");
+    lines.push(colors.dim("Scoring: not included in this release"));
+    lines.push("");
+    if (verbose) {
+        lines.push(colors.dim("Timing"));
+        lines.push(`  Discovery: ${result.timing.discoveryMs}ms`);
+        lines.push(`  Detection: ${result.timing.detectionMs}ms`);
+        lines.push(`  Agents:    ${result.timing.agentsMs}ms`);
+        lines.push(`  Rules:     ${result.timing.rulesMs}ms`);
+        lines.push(`  Total:     ${result.timing.totalMs}ms`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function pad(value, width) {
+    return value.padEnd(width, " ");
+}

package/dist/security/redaction.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Never print secret values. Report paths and risk only.
+ */
+export declare function redactSecretValue(_value: string): string;
+/**
+ * Strip control characters that could hijack terminal output.
+ */
+export declare function sanitizeTerminalText(value: string): string;
+export declare function looksLikeSensitiveFilename(filename: string): boolean;

package/dist/security/redaction.js

@@ -0,0 +1,26 @@
+/**
+ * Never print secret values. Report paths and risk only.
+ */
+export function redactSecretValue(_value) {
+    return "[REDACTED]";
+}
+/**
+ * Strip control characters that could hijack terminal output.
+ */
+export function sanitizeTerminalText(value) {
+    // eslint-disable-next-line no-control-regex -- intentional control-char stripping
+    return value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
+}
+const SENSITIVE_BASENAME_PATTERNS = [
+    /^\.env(\..+)?$/i,
+    /.*credentials.*\.json$/i,
+    /.*secret.*/i,
+    /id_rsa$/i,
+    /id_ed25519$/i,
+    /\.pem$/i,
+    /\.key$/i,
+];
+export function looksLikeSensitiveFilename(filename) {
+    const base = filename.split(/[/\\]/).pop() ?? filename;
+    return SENSITIVE_BASENAME_PATTERNS.some((pattern) => pattern.test(base));
+}

package/dist/types/index.d.ts

@@ -0,0 +1,137 @@
+import type { AgentDetectionResult } from "../agents/types.js";
+/**
+ * AgentDoctor core types.
+ * Designed so scanning stays independent of terminal reporting.
+ */
+export type Severity = "critical" | "warning" | "info";
+export type RuleCategory = "security" | "context" | "instructions" | "mcp" | "performance" | "compatibility";
+export type LanguageId = "typescript" | "javascript" | "python" | "dart" | "php" | "go" | "rust" | "java" | "kotlin" | "unknown";
+export type FrameworkId = "nextjs" | "react" | "vue" | "nuxt" | "svelte" | "nodejs" | "express" | "nestjs" | "flutter" | "laravel" | "django" | "fastapi" | "unknown";
+export type PackageManagerId = "npm" | "pnpm" | "yarn" | "bun" | "composer" | "pip" | "poetry" | "cargo" | "gradle" | "unknown";
+export type MonorepoToolId = "npm-workspaces" | "pnpm-workspaces" | "turborepo" | "nx" | "none";
+export type AgentId = "cursor" | "claude-code" | "codex";
+export interface DiscoveredFile {
+    /** Absolute path */
+    absolutePath: string;
+    /** Path relative to repository root, POSIX-style */
+    relativePath: string;
+    sizeBytes: number;
+    isSymlink: boolean;
+}
+export interface DiscoveryResult {
+    files: DiscoveredFile[];
+    directoriesSkipped: string[];
+    filesSkippedOversized: number;
+    permissionErrors: string[];
+    elapsedMs: number;
+}
+export interface RepositoryInfo {
+    root: string;
+    languages: LanguageId[];
+    primaryLanguage: LanguageId;
+    frameworks: FrameworkId[];
+    primaryFramework: FrameworkId;
+    packageManagers: PackageManagerId[];
+    primaryPackageManager: PackageManagerId;
+    monorepo: MonorepoToolId;
+    filesScanned: number;
+}
+export type { AgentConfigStatus, AgentConfigFile, AgentConfigFileKind, AgentConfigScope, AgentDiagnostic, AgentDetectionResult, } from "../agents/types.js";
+/** @deprecated Prefer AgentDetectionResult — kept for compatibility. */
+export type AgentPresence = AgentDetectionResult;
+export interface FindingEvidence {
+    path?: string;
+    line?: number;
+    detail?: string;
+}
+export type Fixability = "safe" | "review" | "manual" | "none";
+export interface Finding {
+    id: string;
+    ruleId: string;
+    category: RuleCategory;
+    severity: Severity;
+    title: string;
+    message: string;
+    whyItMatters: string;
+    recommendation?: string;
+    affectedAgents: AgentId[];
+    evidence?: FindingEvidence;
+    fixability: Fixability;
+}
+export interface FindingsSummary {
+    critical: number;
+    warning: number;
+    info: number;
+    total: number;
+}
+export interface CategoryScores {
+    security: number;
+    context: number;
+    instructions: number;
+    mcp: number;
+    compatibility: number;
+    performance: number;
+}
+export interface AgentScores {
+    cursor: number;
+    "claude-code": number;
+    codex: number;
+}
+export interface Scores {
+    overall: number;
+    categories: CategoryScores;
+    agents: AgentScores;
+}
+export interface TimingInfo {
+    discoveryMs: number;
+    detectionMs: number;
+    agentsMs: number;
+    rulesMs: number;
+    scoringMs: number;
+    totalMs: number;
+}
+export interface ScanDiagnostics {
+    warnings: string[];
+    errors: string[];
+}
+export interface ScanResult {
+    version: string;
+    repository: RepositoryInfo;
+    agents: AgentDetectionResult[];
+    findings: Finding[];
+    summary: FindingsSummary;
+    /**
+     * Readiness scores when scoring is available.
+     * Null while scoring is unavailable — do not treat as readiness.
+     */
+    scores: Scores | null;
+    /** False until the readiness scoring model ships. */
+    scoringAvailable: boolean;
+    timing: TimingInfo;
+    diagnostics: ScanDiagnostics;
+}
+export interface ScanOptions {
+    cwd?: string;
+    /** Max file size to read/stat deeply; oversized files are counted but skipped for content */
+    maxFileSizeBytes?: number;
+    verbose?: boolean;
+    /** Optional filter for which rule IDs to run */
+    includeRules?: string[];
+    excludeRules?: string[];
+}
+export interface CliOptions {
+    path?: string;
+    json?: boolean;
+    ci?: boolean;
+    verbose?: boolean;
+    minScore?: number;
+    dryRun?: boolean;
+    yes?: boolean;
+}
+export declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly ISSUES_OR_THRESHOLD: 1;
+    readonly USAGE_ERROR: 2;
+    readonly INTERNAL_ERROR: 3;
+};
+export type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];

package/dist/types/index.js

@@ -0,0 +1,6 @@
+export const EXIT_CODES = {
+    SUCCESS: 0,
+    ISSUES_OR_THRESHOLD: 1,
+    USAGE_ERROR: 2,
+    INTERNAL_ERROR: 3,
+};

package/dist/utils/colors.d.ts

@@ -0,0 +1,14 @@
+export declare const colors: {
+    bold: (s: string) => string;
+    dim: (s: string) => string;
+    cyan: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    red: (s: string) => string;
+    magenta: (s: string) => string;
+    white: (s: string) => string;
+};
+export declare function symbolOk(): string;
+export declare function symbolWarn(): string;
+export declare function symbolFail(): string;
+export declare function symbolInfo(): string;

package/dist/utils/colors.js

@@ -0,0 +1,26 @@
+import pc from "picocolors";
+const useColor = !("NO_COLOR" in process.env) &&
+    process.env["FORCE_COLOR"] !== "0" &&
+    process.stdout.isTTY === true;
+export const colors = {
+    bold: (s) => (useColor ? pc.bold(s) : s),
+    dim: (s) => (useColor ? pc.dim(s) : s),
+    cyan: (s) => (useColor ? pc.cyan(s) : s),
+    green: (s) => (useColor ? pc.green(s) : s),
+    yellow: (s) => (useColor ? pc.yellow(s) : s),
+    red: (s) => (useColor ? pc.red(s) : s),
+    magenta: (s) => (useColor ? pc.magenta(s) : s),
+    white: (s) => (useColor ? pc.white(s) : s),
+};
+export function symbolOk() {
+    return colors.green("✓");
+}
+export function symbolWarn() {
+    return colors.yellow("!");
+}
+export function symbolFail() {
+    return colors.red("✗");
+}
+export function symbolInfo() {
+    return colors.cyan("i");
+}

package/dist/utils/fs.d.ts

@@ -0,0 +1,17 @@
+export declare function pathExists(target: string): Promise<boolean>;
+export declare function isDirectory(target: string): Promise<boolean>;
+export declare function readTextFile(filePath: string, maxBytes: number): Promise<string | null>;
+export declare function readJsonFile<T>(filePath: string, maxBytes: number): Promise<{
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare function listDirectorySafe(dirPath: string): Promise<{
+    ok: true;
+    entries: string[];
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/utils/fs.js

@@ -0,0 +1,63 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function pathExists(target) {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isDirectory(target) {
+    try {
+        const stat = await fs.stat(target);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function readTextFile(filePath, maxBytes) {
+    try {
+        const handle = await fs.open(filePath, "r");
+        try {
+            const stat = await handle.stat();
+            if (stat.size > maxBytes) {
+                return null;
+            }
+            const buffer = Buffer.alloc(Number(stat.size));
+            await handle.read(buffer, 0, buffer.length, 0);
+            return buffer.toString("utf8");
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+export async function readJsonFile(filePath, maxBytes) {
+    const text = await readTextFile(filePath, maxBytes);
+    if (text === null) {
+        return { ok: false, error: `Unable to read or file too large: ${path.basename(filePath)}` };
+    }
+    try {
+        return { ok: true, data: JSON.parse(text) };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Invalid JSON";
+        return { ok: false, error: message };
+    }
+}
+export async function listDirectorySafe(dirPath) {
+    try {
+        const entries = await fs.readdir(dirPath);
+        return { ok: true, entries };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unable to read directory";
+        return { ok: false, error: message };
+    }
+}

package/dist/utils/path.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolve and normalize a user-supplied path safely.
+ * Rejects empty strings; does not follow symlinks here.
+ */
+export declare function resolveRepoRoot(inputPath: string): string;
+/**
+ * Produce a POSIX-style relative path for stable cross-platform reporting.
+ */
+export declare function toPosixRelative(from: string, to: string): string;
+/**
+ * Ensure a candidate path stays within a root (defense against traversal).
+ */
+export declare function isPathInsideRoot(root: string, candidate: string): boolean;
+/**
+ * Strip ANSI / control characters from strings destined for JSON or logs.
+ */
+export declare function sanitizeForOutput(value: string): string;

package/dist/utils/path.js

@@ -0,0 +1,37 @@
+import path from "node:path";
+/**
+ * Resolve and normalize a user-supplied path safely.
+ * Rejects empty strings; does not follow symlinks here.
+ */
+export function resolveRepoRoot(inputPath) {
+    const trimmed = inputPath.trim();
+    if (!trimmed) {
+        throw new Error("Path must not be empty");
+    }
+    return path.resolve(trimmed);
+}
+/**
+ * Produce a POSIX-style relative path for stable cross-platform reporting.
+ */
+export function toPosixRelative(from, to) {
+    return path.relative(from, to).split(path.sep).join("/");
+}
+/**
+ * Ensure a candidate path stays within a root (defense against traversal).
+ */
+export function isPathInsideRoot(root, candidate) {
+    const normalizedRoot = path.resolve(root);
+    const normalizedCandidate = path.resolve(candidate);
+    if (normalizedCandidate === normalizedRoot) {
+        return true;
+    }
+    const relative = path.relative(normalizedRoot, normalizedCandidate);
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+/**
+ * Strip ANSI / control characters from strings destined for JSON or logs.
+ */
+export function sanitizeForOutput(value) {
+    // eslint-disable-next-line no-control-regex -- intentional control-char stripping
+    return value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@praneeth_54/agentdoctor",
+  "version": "0.1.0-beta",
+  "description": "Audit AI coding agent configuration in a repository — local, deterministic, no API key.",
+  "type": "module",
+  "bin": {
+    "agentdoctor": "dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsx src/cli/index.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.build.json --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "verify": "npm run typecheck && npm run lint && npm run format:check && npm test && npm run build",
+    "prepublishOnly": "npm run verify"
+  },
+  "keywords": [
+    "ai",
+    "coding-agents",
+    "agent-config",
+    "cursor",
+    "claude-code",
+    "codex",
+    "mcp",
+    "security",
+    "linter",
+    "cli",
+    "static-analysis",
+    "developer-tools"
+  ],
+  "author": "AgentDoctor Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pranee54/AgentDoctor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pranee54/AgentDoctor/issues"
+  },
+  "homepage": "https://github.com/pranee54/AgentDoctor#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^22.19.1",
+    "eslint": "^9.39.2",
+    "prettier": "^3.7.4",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.50.0",
+    "vitest": "^3.2.4"
+  }
+}