@densetsuuu/docteur 0.1.1-beta

package/build/src/xray/components/ModuleView.js

@@ -0,0 +1,144 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { formatDuration, getEffectiveTime, getImportChain, getFileIcon, getSourceIcon, getTimeColor, isDependency, } from '../tree.js';
+import { symbols } from '../../profiler/registries/index.js';
+function ItemComponent({ isSelected = false, label }) {
+    if (!label) {
+        return _jsx(Text, { children: " " });
+    }
+    return (_jsx(Text, { color: isSelected ? 'blue' : undefined, bold: isSelected, children: label }));
+}
+// Threshold for suggesting lazy imports (50ms)
+const LAZY_IMPORT_THRESHOLD = 50;
+export function ModuleView({ node, tree: _tree, onNavigate, onBack }) {
+    const importChain = useMemo(() => getImportChain(node), [node]);
+    const time = getEffectiveTime(node.timing);
+    const selfTime = node.timing.loadTime;
+    // Find heavy dependencies that could be lazy loaded
+    const lazyImportCandidates = useMemo(() => {
+        return node.children
+            .filter((child) => {
+            const childTime = getEffectiveTime(child.timing);
+            return childTime >= LAZY_IMPORT_THRESHOLD && isDependency(child.timing.resolvedUrl);
+        })
+            .sort((a, b) => getEffectiveTime(b.timing) - getEffectiveTime(a.timing));
+    }, [node.children]);
+    // Build navigable items list
+    const items = useMemo(() => {
+        const result = [];
+        result.push({
+            key: 'back',
+            label: `${symbols.arrowLeft} Back`,
+            value: 'back',
+        });
+        // Lazy import recommendations
+        if (lazyImportCandidates.length > 0 && !isDependency(node.timing.resolvedUrl)) {
+            result.push({
+                key: 'sep-lazy',
+                label: `--- ${symbols.lightbulb} Lazy Import Candidates ---`,
+                value: 'back',
+            });
+            for (const candidate of lazyImportCandidates.slice(0, 5)) {
+                const childTime = getEffectiveTime(candidate.timing);
+                const pkgName = extractPackageName(candidate.timing.resolvedUrl);
+                result.push({
+                    key: `lazy-${candidate.timing.resolvedUrl}`,
+                    label: `  ${symbols.arrow} ${pkgName} (${formatDuration(childTime)}) - use dynamic import`,
+                    value: candidate,
+                });
+            }
+        }
+        // Import chain (why loaded)
+        if (importChain.length > 1) {
+            result.push({
+                key: 'sep-why',
+                label: '--- Why was this loaded? ---',
+                value: 'back',
+            });
+            for (let i = 0; i < importChain.length - 1; i++) {
+                const chainNode = importChain[i];
+                const indent = '  '.repeat(i);
+                const chainTime = getEffectiveTime(chainNode.timing);
+                const fileIcon = getFileIcon(chainNode.timing.resolvedUrl);
+                const sourceIcon = getSourceIcon(chainNode.timing.resolvedUrl);
+                const isEntry = i === 0;
+                result.push({
+                    key: `chain-${i}-${chainNode.timing.resolvedUrl}`,
+                    label: `${indent}${isEntry ? '\u25B6' : '\u2514\u2500'} ${sourceIcon} ${fileIcon}  ${chainNode.displayName} (${formatDuration(chainTime)})`,
+                    value: chainNode,
+                });
+            }
+            const currentIndent = '  '.repeat(importChain.length - 1);
+            const currentFileIcon = getFileIcon(node.timing.resolvedUrl);
+            const currentSourceIcon = getSourceIcon(node.timing.resolvedUrl);
+            result.push({
+                key: 'current',
+                label: `${currentIndent}\u2514\u2500 ${currentSourceIcon} ${currentFileIcon}  ${node.displayName} ${symbols.arrowLeft} YOU ARE HERE`,
+                value: 'back',
+            });
+        }
+        // Children (what it imports)
+        if (node.children.length > 0) {
+            const sortedChildren = [...node.children].sort((a, b) => getEffectiveTime(b.timing) - getEffectiveTime(a.timing));
+            result.push({
+                key: 'spacer-imports',
+                label: '',
+                value: 'back',
+            });
+            result.push({
+                key: 'sep-imports',
+                label: `--- What it imports (${node.children.length} modules) ---`,
+                value: 'back',
+            });
+            for (let i = 0; i < Math.min(sortedChildren.length, 15); i++) {
+                const child = sortedChildren[i];
+                const childTime = getEffectiveTime(child.timing);
+                const childFileIcon = getFileIcon(child.timing.resolvedUrl);
+                const childSourceIcon = getSourceIcon(child.timing.resolvedUrl);
+                const isHeavy = childTime >= LAZY_IMPORT_THRESHOLD && isDependency(child.timing.resolvedUrl);
+                const childName = simplifyDisplayName(child);
+                result.push({
+                    key: `child-${i}-${child.timing.resolvedUrl}`,
+                    label: `  ${isHeavy ? symbols.warning : '\u25B8'} ${childSourceIcon} ${childFileIcon}  ${childName} (${formatDuration(childTime)})`,
+                    value: child,
+                });
+            }
+            if (sortedChildren.length > 15) {
+                result.push({
+                    key: 'more',
+                    label: `  ... and ${sortedChildren.length - 15} more`,
+                    value: 'back',
+                });
+            }
+        }
+        return result;
+    }, [node, importChain, lazyImportCandidates]);
+    const handleSelect = (item) => {
+        if (item.value === 'back') {
+            if (item.label.includes('Back')) {
+                onBack();
+            }
+            return;
+        }
+        onNavigate(item.value);
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "cyan", children: [' ', '\uf21e', " Module Details"] }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { children: _jsxs(Text, { bold: true, color: "green", children: [' ', node.displayName] }) }), _jsxs(Text, { dimColor: true, children: [" ", node.timing.resolvedUrl] })] }), _jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " Total time: " }), _jsx(Text, { color: getTimeColor(time), children: formatDuration(time) }), _jsx(Text, { dimColor: true, children: " (with dependencies)" })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " Self time:  " }), _jsx(Text, { color: getTimeColor(selfTime), children: formatDuration(selfTime) }), _jsx(Text, { dimColor: true, children: " (this file only)" })] })] }), lazyImportCandidates.length > 0 && !isDependency(node.timing.resolvedUrl) && (_jsxs(Box, { marginBottom: 1, flexDirection: "column", paddingLeft: 1, children: [_jsxs(Text, { color: "yellow", bold: true, children: [symbols.lightbulb, " Optimization tip:"] }), _jsxs(Text, { dimColor: true, children: [' ', "This file imports ", lazyImportCandidates.length, " heavy package(s) that could be"] }), _jsx(Text, { dimColor: true, children: " lazy-loaded with dynamic imports to reduce cold start time:" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: " Before: import xlsx from 'xlsx'" }), _jsx(Text, { dimColor: true, children: " After: const xlsx = await import('xlsx')" })] })] })), _jsx(Box, { flexDirection: "column", children: _jsx(SelectInput, { items: items, onSelect: handleSelect, itemComponent: ItemComponent }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: " Left/ESC/Backspace: back | q: quit" }) })] }));
+}
+function extractPackageName(url) {
+    const match = url.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+    return match?.[1] || url.split('/').pop() || url;
+}
+function simplifyDisplayName(node) {
+    const url = node.timing.resolvedUrl;
+    if (isDependency(url)) {
+        // Find the LAST node_modules/ to handle pnpm store paths
+        // e.g. .pnpm/@pkg@version/node_modules/@scope/pkg/build/index.js
+        const lastIdx = url.lastIndexOf('node_modules/');
+        if (lastIdx !== -1) {
+            return url.slice(lastIdx + 'node_modules/'.length);
+        }
+    }
+    return node.displayName;
+}

package/build/src/xray/components/ProviderListView.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderTiming } from '../../types.js';
+interface Props {
+    providers: ProviderTiming[];
+    onSelect: (provider: ProviderTiming) => void;
+    onSwitchToModules: () => void;
+}
+export declare function ProviderListView({ providers, onSelect, onSwitchToModules }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/src/xray/components/ProviderListView.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { formatDuration, getTimeColor } from '../tree.js';
+import { symbols } from '../../profiler/registries/index.js';
+function ItemComponent({ isSelected = false, timeStr, timeColor, name, label }) {
+    // Spacer
+    if (!label) {
+        return _jsx(Text, { children: " " });
+    }
+    // Switch button
+    if (label.includes('Switch')) {
+        return (_jsx(Text, { color: isSelected ? 'blue' : 'cyan', bold: isSelected, children: label }));
+    }
+    if (isSelected) {
+        return (_jsxs(Text, { color: "blue", bold: true, children: [timeStr, " ", symbols.provider, " ", name] }));
+    }
+    return (_jsxs(Text, { children: [_jsx(Text, { color: timeColor, children: timeStr }), " ", symbols.provider, " ", name] }));
+}
+export function ProviderListView({ providers, onSelect, onSwitchToModules }) {
+    const sorted = [...providers].sort((a, b) => b.totalTime - a.totalTime);
+    const items = [
+        ...sorted.map((provider, index) => ({
+            key: `${index}-${provider.name}`,
+            label: provider.name,
+            value: provider,
+            timeStr: formatDuration(provider.totalTime).padStart(10),
+            timeColor: getTimeColor(provider.totalTime),
+            name: provider.name,
+        })),
+        {
+            key: 'spacer',
+            label: '',
+            value: 'switch',
+            timeStr: '',
+            timeColor: 'green',
+            name: '',
+        },
+        {
+            key: 'switch',
+            label: `${symbols.turtle} Switch to Modules (Tab)`,
+            value: 'switch',
+            timeStr: '',
+            timeColor: 'green',
+            name: '',
+        },
+    ];
+    const handleSelect = (item) => {
+        if (item.value === 'switch') {
+            onSwitchToModules();
+        }
+        else {
+            onSelect(item.value);
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "cyan", children: [' ', symbols.lightning, " Docteur X-Ray - Provider Explorer"] }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: [' ', "Time spent in register() + boot() + start() + ready() lifecycle methods"] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: " Use arrows to navigate, Enter to inspect, ESC to quit" }) }), _jsx(Box, { flexDirection: "column", children: _jsx(SelectInput, { items: items, onSelect: handleSelect, itemComponent: ItemComponent }) })] }));
+}

package/build/src/xray/components/ProviderView.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderTiming } from '../../types.js';
+interface Props {
+    provider: ProviderTiming;
+    onBack: () => void;
+}
+export declare function ProviderView({ provider, onBack }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/src/xray/components/ProviderView.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { formatDuration, getTimeColor } from '../tree.js';
+import { symbols } from '../../profiler/registries/index.js';
+function Bar({ value, max, width = 30 }) {
+    const ratio = max > 0 ? Math.min(value / max, 1) : 0;
+    const filled = Math.round(ratio * width);
+    const bar = symbols.barFull.repeat(filled) + symbols.barEmpty.repeat(width - filled);
+    const color = getTimeColor(value);
+    return _jsx(Text, { color: color, children: bar });
+}
+function PhaseRow({ label, value, max }) {
+    const timeStr = formatDuration(value).padStart(10);
+    const color = getTimeColor(value);
+    return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: label.padEnd(12) }), _jsx(Text, { color: color, children: timeStr }), _jsx(Text, { children: " " }), _jsx(Bar, { value: value, max: max, width: 25 })] }));
+}
+export function ProviderView({ provider, onBack }) {
+    const phases = [
+        { label: 'register()', value: provider.registerTime },
+        { label: 'boot()', value: provider.bootTime },
+        { label: 'start()', value: provider.startTime },
+        { label: 'ready()', value: provider.readyTime },
+    ];
+    const maxPhaseTime = Math.max(...phases.map((p) => p.value), 1);
+    const items = [
+        { key: 'back', label: `${symbols.arrowLeft} Back`, value: 'back' },
+    ];
+    const handleSelect = (item) => {
+        if (item.value === 'back') {
+            onBack();
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "cyan", children: [' ', symbols.lightning, " Provider Details"] }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { children: _jsxs(Text, { bold: true, color: "green", children: [' ', symbols.provider, " ", provider.name] }) }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " Total execution time: " }), _jsx(Text, { color: getTimeColor(provider.totalTime), children: formatDuration(provider.totalTime) })] })] }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, children: " Lifecycle Breakdown:" }), _jsx(Text, { dimColor: true, children: " Time spent in each provider method" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: phases.map((phase) => (_jsx(PhaseRow, { label: phase.label, value: phase.value, max: maxPhaseTime }, phase.label))) })] }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 1, children: [_jsxs(Text, { dimColor: true, children: [symbols.bullet, " register(): Container bindings, executed for all providers first"] }), _jsxs(Text, { dimColor: true, children: [symbols.bullet, " boot(): Initialization logic, after all providers registered"] }), _jsxs(Text, { dimColor: true, children: [symbols.bullet, " start(): Called when HTTP server starts"] }), _jsxs(Text, { dimColor: true, children: [symbols.bullet, " ready(): Called when app is fully ready"] })] }), _jsx(Box, { flexDirection: "column", children: _jsx(SelectInput, { items: items, onSelect: handleSelect }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: " Left/ESC/Backspace: back | q: quit" }) })] }));
+}

package/build/src/xray/components/XRayApp.d.ts

@@ -0,0 +1,7 @@
+import type { ProfileResult } from '../../types.js';
+interface Props {
+    result: ProfileResult;
+    cwd: string;
+}
+export declare function XRayApp({ result, cwd }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/src/xray/components/XRayApp.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useMemo, useCallback } from 'react';
+import { useApp, useInput, useStdout } from 'ink';
+import { buildDependencyTree } from '../tree.js';
+import { ListView } from './ListView.js';
+import { ModuleView } from './ModuleView.js';
+import { ProviderListView } from './ProviderListView.js';
+import { ProviderView } from './ProviderView.js';
+export function XRayApp({ result, cwd }) {
+    const { exit } = useApp();
+    const { write } = useStdout();
+    const [view, setView] = useState('modules');
+    const [moduleHistory, setModuleHistory] = useState([]);
+    const [selectedProvider, setSelectedProvider] = useState(null);
+    const tree = useMemo(() => buildDependencyTree(result.modules, cwd), [result.modules, cwd]);
+    const currentModule = moduleHistory.length > 0 ? moduleHistory[moduleHistory.length - 1] : null;
+    const clearScreen = useCallback(() => {
+        write('\x1b[2J\x1b[H');
+    }, [write]);
+    const navigateToModule = (node) => {
+        clearScreen();
+        setModuleHistory([...moduleHistory, node]);
+    };
+    const goBack = () => {
+        clearScreen();
+        if (selectedProvider) {
+            setSelectedProvider(null);
+        }
+        else if (moduleHistory.length > 0) {
+            setModuleHistory(moduleHistory.slice(0, -1));
+        }
+    };
+    const switchView = (newView) => {
+        clearScreen();
+        setView(newView);
+        setModuleHistory([]);
+        setSelectedProvider(null);
+    };
+    useInput((input, key) => {
+        if (input === 'q') {
+            exit();
+        }
+        if (key.leftArrow || key.backspace || key.delete) {
+            if (selectedProvider || moduleHistory.length > 0) {
+                goBack();
+            }
+        }
+        if (key.escape) {
+            if (selectedProvider || moduleHistory.length > 0) {
+                goBack();
+            }
+            else {
+                exit();
+            }
+        }
+        // Tab to switch between views (when at root)
+        if (key.tab && !currentModule && !selectedProvider) {
+            switchView(view === 'modules' ? 'providers' : 'modules');
+        }
+    });
+    // Provider detail view
+    if (selectedProvider) {
+        return _jsx(ProviderView, { provider: selectedProvider, onBack: goBack });
+    }
+    // Module detail view
+    if (currentModule) {
+        return (_jsx(ModuleView, { node: currentModule, tree: tree, onNavigate: navigateToModule, onBack: goBack }));
+    }
+    // Providers list view
+    if (view === 'providers') {
+        return (_jsx(ProviderListView, { providers: result.providers, onSelect: (p) => {
+                clearScreen();
+                setSelectedProvider(p);
+            }, onSwitchToModules: () => switchView('modules') }));
+    }
+    // Modules list view (default)
+    return (_jsx(ListView, { tree: tree, onSelect: navigateToModule, onSwitchToProviders: () => switchView('providers'), hasProviders: result.providers.length > 0 }));
+}

package/build/src/xray/tree.d.ts

@@ -0,0 +1,22 @@
+import type { ModuleTiming } from '../types.js';
+import { formatDuration, getEffectiveTime } from '../profiler/reporters/format.js';
+export interface ModuleNode {
+    timing: ModuleTiming;
+    displayName: string;
+    children: ModuleNode[];
+    parent?: ModuleNode;
+    depth: number;
+}
+export interface DependencyTree {
+    nodeMap: Map<string, ModuleNode>;
+    roots: ModuleNode[];
+    sortedByTime: ModuleNode[];
+}
+export declare function buildDependencyTree(modules: ModuleTiming[], cwd: string): DependencyTree;
+export declare function getImportChain(node: ModuleNode): ModuleNode[];
+export declare function getFileIcon(url: string): string;
+export type TimeColor = 'red' | 'yellow' | 'cyan' | 'green';
+export declare function getTimeColor(ms: number): TimeColor;
+export declare function isDependency(url: string): boolean;
+export declare function getSourceIcon(url: string): string;
+export { formatDuration, getEffectiveTime };

package/build/src/xray/tree.js

@@ -0,0 +1,85 @@
+/*
+|--------------------------------------------------------------------------
+| Dependency Tree
+|--------------------------------------------------------------------------
+|
+| Builds a tree structure from module timings for the xray TUI.
+| Provides utilities for traversing and displaying the tree.
+|
+*/
+import { formatDuration, getEffectiveTime, simplifyUrl } from '../profiler/reporters/format.js';
+import { fileIcons, symbols } from '../profiler/registries/index.js';
+export function buildDependencyTree(modules, cwd) {
+    const nodeMap = new Map();
+    const time = (n) => getEffectiveTime(n.timing);
+    // Create all nodes
+    for (const timing of modules) {
+        nodeMap.set(timing.resolvedUrl, {
+            timing,
+            displayName: simplifyUrl(timing.resolvedUrl, cwd),
+            children: [],
+            depth: 0,
+        });
+    }
+    for (const node of nodeMap.values()) {
+        const parentUrl = node.timing.parentUrl;
+        if (parentUrl && nodeMap.has(parentUrl)) {
+            const parent = nodeMap.get(parentUrl);
+            parent.children.push(node);
+            node.parent = parent;
+        }
+    }
+    // Calculate depths and identify roots
+    const roots = [];
+    const setDepths = (node, depth, seen = new Set()) => {
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        node.depth = depth;
+        for (const child of node.children)
+            setDepths(child, depth + 1, seen);
+    };
+    for (const node of nodeMap.values()) {
+        if (!node.parent) {
+            roots.push(node);
+            setDepths(node, 0);
+        }
+    }
+    // Sort children by time (slowest first)
+    for (const node of nodeMap.values()) {
+        node.children.sort((a, b) => time(b) - time(a));
+    }
+    const sortedByTime = [...nodeMap.values()].sort((a, b) => time(b) - time(a));
+    return { nodeMap, roots, sortedByTime };
+}
+export function getImportChain(node) {
+    const chain = [];
+    const seen = new Set();
+    let current = node;
+    while (current && !seen.has(current)) {
+        seen.add(current);
+        chain.unshift(current);
+        current = current.parent;
+    }
+    return chain;
+}
+export function getFileIcon(url) {
+    const ext = url.split('.').pop()?.toLowerCase() || '';
+    return fileIcons[ext] || fileIcons.default;
+}
+export function getTimeColor(ms) {
+    if (ms >= 100)
+        return 'red';
+    if (ms >= 50)
+        return 'yellow';
+    if (ms >= 10)
+        return 'cyan';
+    return 'green';
+}
+export function isDependency(url) {
+    return url.includes('/node_modules/');
+}
+export function getSourceIcon(url) {
+    return isDependency(url) ? symbols.sourcePackage : symbols.sourceHome;
+}
+export { formatDuration, getEffectiveTime };

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@densetsuuu/docteur",
+  "description": "AdonisJS cold start profiler - analyze and optimize your application boot time",
+  "version": "0.1.1-beta",
+  "engines": {
+    "node": ">=21.0.0"
+  },
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "type": "module",
+  "bin": {
+    "docteur": "./build/src/cli/main.js"
+  },
+  "files": [
+    "build/src",
+    "build/index.d.ts",
+    "build/index.js"
+  ],
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js"
+    },
+    "./types": "./build/src/types.js",
+    "./profiler/loader": "./build/src/profiler/loader.js",
+    "./profiler/hooks": "./build/src/profiler/hooks.js"
+  },
+  "scripts": {
+    "clean": "del-cli build",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "quick:test": "node --import=./tsnode.esm.js --enable-source-maps bin/test.ts",
+    "pretest": "npm run lint",
+    "test": "c8 npm run quick:test",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "tsc",
+    "release": "np",
+    "version": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "adonisjs",
+    "adonis",
+    "profiler",
+    "cold-start",
+    "performance",
+    "diagnostics",
+    "boot-time",
+    "cli"
+  ],
+  "author": "Densetsuuu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/densetsuuu/docteur.git"
+  },
+  "bugs": {
+    "url": "https://github.com/densetsuuu/docteur/issues"
+  },
+  "homepage": "https://github.com/densetsuuu/docteur#readme",
+  "dependencies": {
+    "@poppinss/cliui": "^6.6.0",
+    "citty": "^0.2.0",
+    "ink": "^5.2.1",
+    "ink-select-input": "^6.2.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@adonisjs/application": "9.0.0-next.15",
+    "@adonisjs/eslint-config": "^3.0.0-next.9",
+    "@adonisjs/prettier-config": "^1.4.5",
+    "@adonisjs/tsconfig": "^2.0.0-next.3",
+    "@japa/assert": "^4.2.0",
+    "@japa/runner": "^5.0.0",
+    "@swc/core": "^1.6.3",
+    "@types/node": "^25.0.3",
+    "@types/react": "^18.3.27",
+    "c8": "^10.1.2",
+    "del-cli": "^5.1.0",
+    "eslint": "^9.15.0",
+    "np": "^10.0.6",
+    "prettier": "^3.3.2",
+    "ts-node-maintained": "^10.9.4",
+    "typescript": "^5.4.5"
+  },
+  "peerDependencies": {
+    "@adonisjs/application": ">=9.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "np": {
+    "message": "chore(release): %s",
+    "tag": "latest",
+    "branch": "main",
+    "anyBranch": false
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**"
+    ]
+  },
+  "prettier": "@adonisjs/prettier-config"
+}