@grafema/cli 0.1.1-alpha → 0.2.1-beta

package/dist/cli.js

@@ -7,6 +7,8 @@ import { initCommand } from './commands/init.js';
 import { analyzeCommand } from './commands/analyze.js';
 import { overviewCommand } from './commands/overview.js';
 import { queryCommand } from './commands/query.js';
+import { typesCommand } from './commands/types.js';
+import { lsCommand } from './commands/ls.js';
 import { getCommand } from './commands/get.js';
 import { traceCommand } from './commands/trace.js';
 import { impactCommand } from './commands/impact.js';
@@ -15,6 +17,9 @@ import { statsCommand } from './commands/stats.js';
 import { checkCommand } from './commands/check.js';
 import { serverCommand } from './commands/server.js';
 import { coverageCommand } from './commands/coverage.js';
+import { doctorCommand } from './commands/doctor.js';
+import { schemaCommand } from './commands/schema.js';
+import { explainCommand } from './commands/explain.js';
 const program = new Command();
 program
     .name('grafema')
@@ -25,6 +30,8 @@ program.addCommand(initCommand);
 program.addCommand(analyzeCommand);
 program.addCommand(overviewCommand);
 program.addCommand(queryCommand);
+program.addCommand(typesCommand);
+program.addCommand(lsCommand);
 program.addCommand(getCommand);
 program.addCommand(traceCommand);
 program.addCommand(impactCommand);
@@ -33,4 +40,7 @@ program.addCommand(statsCommand); // Keep for backwards compat
 program.addCommand(coverageCommand);
 program.addCommand(checkCommand);
 program.addCommand(serverCommand);
+program.addCommand(doctorCommand);
+program.addCommand(schemaCommand);
+program.addCommand(explainCommand);
 program.parse();

package/dist/commands/analyze.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/commands/analyze.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyHpC,eAAO,MAAM,cAAc,SAiJvB,CAAC"}
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/commands/analyze.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgLpC,eAAO,MAAM,cAAc,SAqKvB,CAAC"}

package/dist/commands/analyze.js

@@ -3,18 +3,19 @@
  */
 import { Command } from 'commander';
 import { resolve, join } from 'path';
-import { existsSync, mkdirSync } from 'fs';
+import { existsSync, mkdirSync, readdirSync } from 'fs';
+import { pathToFileURL } from 'url';
 import { Orchestrator, RFDBServerBackend, DiagnosticReporter, DiagnosticWriter, createLogger, loadConfig, 
 // Discovery
 SimpleProjectDiscovery, MonorepoServiceDiscovery, WorkspaceDiscovery, 
 // Indexing
 JSModuleIndexer, RustModuleIndexer, 
 // Analysis
-JSASTAnalyzer, ExpressRouteAnalyzer, SocketIOAnalyzer, DatabaseAnalyzer, FetchAnalyzer, ServiceLayerAnalyzer, ReactAnalyzer, RustAnalyzer, 
+JSASTAnalyzer, ExpressRouteAnalyzer, ExpressResponseAnalyzer, SocketIOAnalyzer, DatabaseAnalyzer, FetchAnalyzer, ServiceLayerAnalyzer, ReactAnalyzer, RustAnalyzer, 
 // Enrichment
-MethodCallResolver, AliasTracker, ValueDomainAnalyzer, MountPointResolver, PrefixEvaluator, InstanceOfResolver, ImportExportLinker, HTTPConnectionEnricher, RustFFIEnricher, 
+MethodCallResolver, ArgumentParameterLinker, AliasTracker, ValueDomainAnalyzer, MountPointResolver, PrefixEvaluator, InstanceOfResolver, ImportExportLinker, FunctionCallResolver, HTTPConnectionEnricher, RustFFIEnricher, 
 // Validation
-CallResolverValidator, EvalBanValidator, SQLInjectionValidator, ShadowingDetector, GraphConnectivityValidator, DataFlowValidator, TypeScriptDeadCodeValidator, } from '@grafema/core';
+CallResolverValidator, EvalBanValidator, SQLInjectionValidator, ShadowingDetector, GraphConnectivityValidator, DataFlowValidator, TypeScriptDeadCodeValidator, BrokenImportValidator, } from '@grafema/core';
 const BUILTIN_PLUGINS = {
     // Discovery
     SimpleProjectDiscovery: () => new SimpleProjectDiscovery(),
@@ -26,6 +27,7 @@ const BUILTIN_PLUGINS = {
     // Analysis
     JSASTAnalyzer: () => new JSASTAnalyzer(),
     ExpressRouteAnalyzer: () => new ExpressRouteAnalyzer(),
+    ExpressResponseAnalyzer: () => new ExpressResponseAnalyzer(),
     SocketIOAnalyzer: () => new SocketIOAnalyzer(),
     DatabaseAnalyzer: () => new DatabaseAnalyzer(),
     FetchAnalyzer: () => new FetchAnalyzer(),
@@ -34,12 +36,14 @@ const BUILTIN_PLUGINS = {
     RustAnalyzer: () => new RustAnalyzer(),
     // Enrichment
     MethodCallResolver: () => new MethodCallResolver(),
+    ArgumentParameterLinker: () => new ArgumentParameterLinker(),
     AliasTracker: () => new AliasTracker(),
     ValueDomainAnalyzer: () => new ValueDomainAnalyzer(),
     MountPointResolver: () => new MountPointResolver(),
     PrefixEvaluator: () => new PrefixEvaluator(),
     InstanceOfResolver: () => new InstanceOfResolver(),
     ImportExportLinker: () => new ImportExportLinker(),
+    FunctionCallResolver: () => new FunctionCallResolver(),
     HTTPConnectionEnricher: () => new HTTPConnectionEnricher(),
     RustFFIEnricher: () => new RustFFIEnricher(),
     // Validation
@@ -50,14 +54,49 @@ const BUILTIN_PLUGINS = {
     GraphConnectivityValidator: () => new GraphConnectivityValidator(),
     DataFlowValidator: () => new DataFlowValidator(),
     TypeScriptDeadCodeValidator: () => new TypeScriptDeadCodeValidator(),
+    BrokenImportValidator: () => new BrokenImportValidator(),
 };
-function createPlugins(config) {
+/**
+ * Load custom plugins from .grafema/plugins/ directory
+ */
+async function loadCustomPlugins(projectPath, log) {
+    const pluginsDir = join(projectPath, '.grafema', 'plugins');
+    if (!existsSync(pluginsDir)) {
+        return {};
+    }
+    const customPlugins = {};
+    try {
+        const files = readdirSync(pluginsDir).filter((f) => f.endsWith('.js') || f.endsWith('.mjs'));
+        for (const file of files) {
+            try {
+                const pluginPath = join(pluginsDir, file);
+                const pluginUrl = pathToFileURL(pluginPath).href;
+                const module = await import(pluginUrl);
+                const PluginClass = module.default || module[file.replace(/\.(m?js)$/, '')];
+                if (PluginClass && typeof PluginClass === 'function') {
+                    const pluginName = PluginClass.name || file.replace(/\.(m?js)$/, '');
+                    customPlugins[pluginName] = () => new PluginClass();
+                    log(`Loaded custom plugin: ${pluginName}`);
+                }
+            }
+            catch (err) {
+                console.warn(`Failed to load plugin ${file}: ${err.message}`);
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`Error loading custom plugins: ${err.message}`);
+    }
+    return customPlugins;
+}
+function createPlugins(config, customPlugins = {}) {
     const plugins = [];
     const phases = ['discovery', 'indexing', 'analysis', 'enrichment', 'validation'];
     for (const phase of phases) {
         const names = config[phase] || [];
         for (const name of names) {
-            const factory = BUILTIN_PLUGINS[name];
+            // Check built-in first, then custom
+            const factory = BUILTIN_PLUGINS[name] || customPlugins[name];
             if (factory) {
                 plugins.push(factory());
             }
@@ -95,6 +134,17 @@ export const analyzeCommand = new Command('analyze')
     .option('-v, --verbose', 'Show verbose logging')
     .option('--debug', 'Enable debug mode (writes diagnostics.log)')
     .option('--log-level <level>', 'Set log level (silent, errors, warnings, info, debug)')
+    .option('--strict', 'Enable strict mode (fail on unresolved references)')
+    .addHelpText('after', `
+Examples:
+  grafema analyze                Analyze current project
+  grafema analyze ./my-project   Analyze specific directory
+  grafema analyze --clear        Clear database and rebuild from scratch
+  grafema analyze -s api         Analyze only "api" service (monorepo)
+  grafema analyze -v             Verbose output with progress details
+  grafema analyze --debug        Write diagnostics.log for debugging
+  grafema analyze --strict       Fail on unresolved references (debugging)
+`)
     .action(async (path, options) => {
     const projectPath = resolve(path);
     const grafemaDir = join(projectPath, '.grafema');
@@ -122,8 +172,15 @@ export const analyzeCommand = new Command('analyze')
             log(`  - ${svc.name}: ${svc.path}${entry}`);
         }
     }
-    const plugins = createPlugins(config.plugins);
+    // Load custom plugins from .grafema/plugins/
+    const customPlugins = await loadCustomPlugins(projectPath, log);
+    const plugins = createPlugins(config.plugins, customPlugins);
     log(`Loaded ${plugins.length} plugins`);
+    // Resolve strict mode: CLI flag overrides config
+    const strictMode = options.strict ?? config.strict ?? false;
+    if (strictMode) {
+        log('Strict mode enabled - analysis will fail on unresolved references');
+    }
     const startTime = Date.now();
     const orchestrator = new Orchestrator({
         graph: backend,
@@ -133,6 +190,7 @@ export const analyzeCommand = new Command('analyze')
         forceAnalysis: options.clear || false,
         logger,
         services: config.services.length > 0 ? config.services : undefined, // Pass config services (REG-174)
+        strictMode, // REG-330: Pass strict mode flag
         onProgress: (progress) => {
             if (options.verbose) {
                 log(`[${progress.phase}] ${progress.message}`);
@@ -155,17 +213,17 @@ export const analyzeCommand = new Command('analyze')
         // Print summary if there are any issues
         if (diagnostics.count() > 0) {
             log('');
-            log(reporter.summary());
+            log(reporter.categorizedSummary());
             // In verbose mode, print full report
             if (options.verbose) {
                 log('');
                 log(reporter.report({ format: 'text', includeSummary: false }));
             }
         }
-        // Write diagnostics.log in debug mode
+        // Always write diagnostics.log (required for `grafema check` command)
+        const writer = new DiagnosticWriter();
+        await writer.write(diagnostics, grafemaDir);
         if (options.debug) {
-            const writer = new DiagnosticWriter();
-            await writer.write(diagnostics, grafemaDir);
             log(`Diagnostics written to ${writer.getLogPath(grafemaDir)}`);
         }
         // Determine exit code based on severity

package/dist/commands/check.d.ts

@@ -6,5 +6,11 @@
  * 2. Built-in validators: --guarantee=<name> (e.g., --guarantee=node-creation)
  */
 import { Command } from 'commander';
+export interface DiagnosticCheckCategory {
+    name: string;
+    description: string;
+    codes: string[];
+}
+export declare const CHECK_CATEGORIES: Record<string, DiagnosticCheckCategory>;
 export declare const checkCommand: Command;
 //# sourceMappingURL=check.d.ts.map

package/dist/commands/check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgCpC,eAAO,MAAM,YAAY,SAwMtB,CAAC"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiCpC,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAGD,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAqBpE,CAAC;AAEF,eAAO,MAAM,YAAY,SA2OtB,CAAC"}

package/dist/commands/check.js

@@ -7,7 +7,7 @@
  */
 import { Command } from 'commander';
 import { resolve, join } from 'path';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { RFDBServerBackend, GuaranteeManager, NodeCreationValidator, GraphFreshnessChecker, IncrementalReanalyzer } from '@grafema/core';
 import { exitWithError } from '../utils/errorFormatter.js';
 // Available built-in validators
@@ -17,6 +17,29 @@ const BUILT_IN_VALIDATORS = {
         description: 'Validates that all nodes are created through NodeFactory'
     }
 };
+// Available diagnostic categories
+export const CHECK_CATEGORIES = {
+    'connectivity': {
+        name: 'Graph Connectivity',
+        description: 'Check for disconnected nodes in the graph',
+        codes: ['ERR_DISCONNECTED_NODES', 'ERR_DISCONNECTED_NODE'],
+    },
+    'calls': {
+        name: 'Call Resolution',
+        description: 'Check for unresolved function calls',
+        codes: ['ERR_UNRESOLVED_CALL'],
+    },
+    'dataflow': {
+        name: 'Data Flow',
+        description: 'Check for missing assignments and broken references',
+        codes: ['ERR_MISSING_ASSIGNMENT', 'ERR_BROKEN_REFERENCE', 'ERR_NO_LEAF_NODE'],
+    },
+    'imports': {
+        name: 'Import Validation',
+        description: 'Check for broken imports and undefined symbols',
+        codes: ['ERR_BROKEN_IMPORT', 'ERR_UNDEFINED_SYMBOL'],
+    },
+};
 export const checkCommand = new Command('check')
     .description('Check invariants/guarantees')
     .argument('[rule]', 'Specific rule ID to check (or "all" for all rules)')
@@ -26,9 +49,36 @@ export const checkCommand = new Command('check')
     .option('-j, --json', 'Output results as JSON')
     .option('-q, --quiet', 'Only output failures')
     .option('--list-guarantees', 'List available built-in guarantees')
+    .option('--list-categories', 'List available diagnostic categories')
     .option('--skip-reanalysis', 'Skip automatic reanalysis of stale modules')
     .option('--fail-on-stale', 'Exit with error if stale modules found (CI mode)')
+    .addHelpText('after', `
+Examples:
+  grafema check                          Run all guarantee checks
+  grafema check connectivity             Check graph connectivity
+  grafema check calls                    Check call resolution
+  grafema check dataflow                 Check data flow integrity
+  grafema check all                      Run all diagnostic categories
+  grafema check --guarantee node-creation    Run built-in validator
+  grafema check --list-categories        List available categories
+  grafema check --list-guarantees        List built-in guarantees
+  grafema check --fail-on-stale          CI mode: fail if graph is stale
+  grafema check -q                       Only show failures (quiet mode)
+`)
     .action(async (rule, options) => {
+    // List available categories
+    if (options.listCategories) {
+        console.log('Available diagnostic categories:');
+        console.log('');
+        for (const [key, category] of Object.entries(CHECK_CATEGORIES)) {
+            console.log(`  ${key}`);
+            console.log(`    ${category.name}`);
+            console.log(`    ${category.description}`);
+            console.log(`    Usage: grafema check ${key}`);
+            console.log('');
+        }
+        return;
+    }
     // List available guarantees
     if (options.listGuarantees) {
         console.log('Available built-in guarantees:');
@@ -40,6 +90,11 @@ export const checkCommand = new Command('check')
         }
         return;
     }
+    // Check if rule argument is a category name
+    if (rule && (rule in CHECK_CATEGORIES || rule === 'all')) {
+        await runCategoryCheck(rule, options);
+        return;
+    }
     // Run built-in guarantee validator
     if (options.guarantee) {
         const validatorInfo = BUILT_IN_VALIDATORS[options.guarantee];
@@ -293,3 +348,124 @@ async function runBuiltInValidator(guaranteeName, projectPath, options) {
         await backend.close();
     }
 }
+/**
+ * Run category-based diagnostic check
+ */
+async function runCategoryCheck(category, options) {
+    const resolvedPath = resolve(options.project);
+    const grafemaDir = join(resolvedPath, '.grafema');
+    const diagnosticsLogPath = join(grafemaDir, 'diagnostics.log');
+    if (!existsSync(diagnosticsLogPath)) {
+        exitWithError('No diagnostics found', [
+            'Run: grafema analyze',
+            'Diagnostics are collected during analysis'
+        ]);
+    }
+    // Read diagnostics from log file (JSON lines format)
+    const diagnosticsContent = readFileSync(diagnosticsLogPath, 'utf-8');
+    const allDiagnostics = diagnosticsContent
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => {
+        try {
+            return JSON.parse(line);
+        }
+        catch (e) {
+            return null;
+        }
+    })
+        .filter(Boolean);
+    // Filter diagnostics by category codes
+    let filteredDiagnostics = allDiagnostics;
+    if (category !== 'all') {
+        const categoryInfo = CHECK_CATEGORIES[category];
+        if (!categoryInfo) {
+            exitWithError(`Unknown category: ${category}`, [
+                'Use --list-categories to see available options'
+            ]);
+        }
+        filteredDiagnostics = allDiagnostics.filter((d) => categoryInfo.codes.includes(d.code));
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            category: category,
+            total: filteredDiagnostics.length,
+            diagnostics: filteredDiagnostics
+        }, null, 2));
+    }
+    else {
+        const categoryName = category === 'all'
+            ? 'All Categories'
+            : CHECK_CATEGORIES[category].name;
+        if (!options.quiet) {
+            console.log(`Checking ${categoryName}...`);
+            console.log('');
+        }
+        if (filteredDiagnostics.length === 0) {
+            console.log('\x1b[32m✓\x1b[0m No issues found');
+        }
+        else {
+            console.log(`\x1b[33m⚠\x1b[0m Found ${filteredDiagnostics.length} diagnostic(s):`);
+            console.log('');
+            // Group by severity
+            const errors = filteredDiagnostics.filter((d) => d.severity === 'error' || d.severity === 'fatal');
+            const warnings = filteredDiagnostics.filter((d) => d.severity === 'warning');
+            const infos = filteredDiagnostics.filter((d) => d.severity === 'info');
+            // Display errors first
+            if (errors.length > 0) {
+                console.log(`\x1b[31mErrors (${errors.length}):\x1b[0m`);
+                for (const diag of errors.slice(0, 10)) {
+                    const location = diag.file ? `${diag.file}${diag.line ? `:${diag.line}` : ''}` : '';
+                    console.log(`  \x1b[31m•\x1b[0m [${diag.code}] ${diag.message}`);
+                    if (location) {
+                        console.log(`    ${location}`);
+                    }
+                    if (diag.suggestion && !options.quiet) {
+                        console.log(`    Suggestion: ${diag.suggestion}`);
+                    }
+                }
+                if (errors.length > 10) {
+                    console.log(`  ... and ${errors.length - 10} more errors`);
+                }
+                console.log('');
+            }
+            // Display warnings
+            if (warnings.length > 0) {
+                console.log(`\x1b[33mWarnings (${warnings.length}):\x1b[0m`);
+                for (const diag of warnings.slice(0, 10)) {
+                    const location = diag.file ? `${diag.file}${diag.line ? `:${diag.line}` : ''}` : '';
+                    console.log(`  \x1b[33m•\x1b[0m [${diag.code}] ${diag.message}`);
+                    if (location) {
+                        console.log(`    ${location}`);
+                    }
+                    if (diag.suggestion && !options.quiet) {
+                        console.log(`    Suggestion: ${diag.suggestion}`);
+                    }
+                }
+                if (warnings.length > 10) {
+                    console.log(`  ... and ${warnings.length - 10} more warnings`);
+                }
+                console.log('');
+            }
+            // Display infos
+            if (infos.length > 0 && !options.quiet) {
+                console.log(`\x1b[36mInfo (${infos.length}):\x1b[0m`);
+                for (const diag of infos.slice(0, 5)) {
+                    const location = diag.file ? `${diag.file}${diag.line ? `:${diag.line}` : ''}` : '';
+                    console.log(`  \x1b[36m•\x1b[0m [${diag.code}] ${diag.message}`);
+                    if (location) {
+                        console.log(`    ${location}`);
+                    }
+                }
+                if (infos.length > 5) {
+                    console.log(`  ... and ${infos.length - 5} more info messages`);
+                }
+                console.log('');
+            }
+        }
+        console.log('');
+        if (filteredDiagnostics.some((d) => d.severity === 'error' || d.severity === 'fatal')) {
+            process.exit(1);
+        }
+    }
+}

package/dist/commands/coverage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/commands/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,eAAO,MAAM,eAAe,SA6BxB,CAAC"}
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/commands/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,eAAO,MAAM,eAAe,SAoCxB,CAAC"}

package/dist/commands/coverage.js

@@ -16,6 +16,13 @@ export const coverageCommand = new Command('coverage')
     .option('-p, --project <path>', 'Project path', '.')
     .option('-j, --json', 'Output as JSON')
     .option('-v, --verbose', 'Show detailed file lists')
+    .addHelpText('after', `
+Examples:
+  grafema coverage               Show coverage summary
+  grafema coverage --verbose     Show detailed file lists
+  grafema coverage --json        Output coverage as JSON
+  grafema coverage -p ./app      Coverage for specific project
+`)
     .action(async (options) => {
     const projectPath = resolve(options.project);
     const grafemaDir = join(projectPath, '.grafema');

package/dist/commands/doctor/checks.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Diagnostic check functions for `grafema doctor` command - REG-214
+ *
+ * Checks are organized in levels:
+ * - Level 1: Prerequisites (fail-fast) - checkGrafemaInitialized, checkServerStatus
+ * - Level 2: Configuration - checkConfigValidity, checkEntrypoints
+ * - Level 3: Graph Health - checkDatabaseExists, checkGraphStats, checkConnectivity, checkFreshness
+ * - Level 4: Informational - checkVersions
+ */
+import type { DoctorCheckResult } from './types.js';
+/**
+ * Check if .grafema directory exists with config file.
+ * FAIL if not initialized.
+ */
+export declare function checkGrafemaInitialized(projectPath: string): Promise<DoctorCheckResult>;
+/**
+ * Check if RFDB server is running and responsive.
+ * WARN if not running (server starts on-demand during analyze).
+ */
+export declare function checkServerStatus(projectPath: string): Promise<DoctorCheckResult>;
+/**
+ * Validate config file syntax and structure.
+ * Uses existing loadConfig() which throws on errors.
+ */
+export declare function checkConfigValidity(projectPath: string): Promise<DoctorCheckResult>;
+/**
+ * Check that entrypoints can be resolved.
+ * For config-defined services, validates that entrypoint files exist.
+ */
+export declare function checkEntrypoints(projectPath: string): Promise<DoctorCheckResult>;
+/**
+ * Check if database file exists and has data.
+ */
+export declare function checkDatabaseExists(projectPath: string): Promise<DoctorCheckResult>;
+/**
+ * Get graph statistics (requires server running).
+ */
+export declare function checkGraphStats(projectPath: string): Promise<DoctorCheckResult>;
+/**
+ * Check graph connectivity - find disconnected nodes.
+ * Thresholds:
+ *   0-5%: pass (normal for external modules)
+ *   5-20%: warn
+ *   >20%: fail (critical issue)
+ */
+export declare function checkConnectivity(projectPath: string): Promise<DoctorCheckResult>;
+/**
+ * Check if graph is fresh (no stale modules).
+ */
+export declare function checkFreshness(projectPath: string): Promise<DoctorCheckResult>;
+/**
+ * Collect version information (always passes).
+ */
+export declare function checkVersions(projectPath: string): Promise<DoctorCheckResult>;
+//# sourceMappingURL=checks.d.ts.map

package/dist/commands/doctor/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor/checks.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA2BpD;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CAgC5B;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CAkC5B;AAMD;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CA+C5B;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CA+E5B;AAMD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CA6B5B;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CA6C5B;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CAgI5B;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CA4C5B;AAMD;;GAEG;AACH,wBAAsB,aAAa,CACjC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CA6C5B"}