commit 97ca149b08fa878124085ad4fa0a85ce7654d1e8 · knotbin.com/doggo

+332

README.md

···

       1
       +
       # 🐶 Doggo

     

       2
       +
       

     

       3
       +
       > A loyal companion for your documentation journey! Doggo sniffs out undocumented exports in your Deno packages and helps you achieve 100% JSDoc coverage.

     

       4
       +
       

     

       5
       +
       ```

     

       6
       +
               __

     

       7
       +
          (___()'`;

     

       8
       +
          /,___ /`

     

       9
       +
          \\"  \\     "Woof! Let's document that code!"

     

       10
       +
       ```

     

       11
       +
       

     

       12
       +
       [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

     

       13
       +
       [![Deno](https://img.shields.io/badge/Deno-1.40+-blue.svg)](https://deno.land)

     

       14
       +
       

     

       15
       +
       ## 🦴 What is Doggo?

     

       16
       +
       

     

       17
       +
       Doggo is a good boy who helps you maintain documentation quality in your Deno projects! This CLI tool analyzes JSDoc documentation coverage of exported/public symbols in Deno packages, making sure every export has proper documentation - because well-documented code is a treat for everyone! 🍖

     

       18
       +
       

     

       19
       +
       ### 🐾 Key Features

     

       20
       +
       

     

       21
       +
       - 🔍 **Sniffs Out Exports** - Automatically detects all exported symbols (functions, classes, interfaces, types, constants, variables, enums)

     

       22
       +
       - 📝 **JSDoc Tracking** - Checks which exports have been properly documented with JSDoc

     

       23
       +
       - 🎯 **Smart Fetch** - When a `deno.json` with `exports` field is found, analyzes only the actual public API (no chasing squirrels!)

     

       24
       +
       - 🏢 **Pack Support** - Analyzes all members in a Deno workspace with aggregate statistics

     

       25
       +
       - 📊 **Detailed Reports** - Get coverage percentages overall and by symbol type

     

       26
       +
       - 🎨 **Pretty Output** - Color-coded terminal output that's easy on the eyes

     

       27
       +
       - ⚡ **Fast & Lightweight** - Built with Deno's standard library (no heavy dependencies to slow us down!)

     

       28
       +
       

     

       29
       +
       ## 🚀 Quick Start

     

       30
       +
       

     

       31
       +
       ### Fetch the ball... I mean, analyze your code!

     

       32
       +
       

     

       33
       +
       ```bash

     

       34
       +
       # Let Doggo analyze the current directory

     

       35
       +
       deno run --allow-read https://deno.land/x/doggo/main.ts

     

       36
       +
       

     

       37
       +
       # Point Doggo to a specific directory

     

       38
       +
       deno run --allow-read https://deno.land/x/doggo/main.ts ./src

     

       39
       +
       

     

       40
       +
       # Analyze a single file

     

       41
       +
       deno run --allow-read https://deno.land/x/doggo/main.ts ./src/module.ts

     

       42
       +
       ```

     

       43
       +
       

     

       44
       +
       ### 🏠 Train Doggo (Install)

     

       45
       +
       

     

       46
       +
       ```bash

     

       47
       +
       # Install Doggo as a good boy on your system

     

       48
       +
       deno install --allow-read -n doggo https://deno.land/x/doggo/main.ts

     

       49
       +
       

     

       50
       +
       # Now you can call Doggo anytime!

     

       51
       +
       doggo

     

       52
       +
       doggo ./src

     

       53
       +
       doggo --help

     

       54
       +
       ```

     

       55
       +
       

     

       56
       +
       ### 🎾 Workspace Mode

     

       57
       +
       

     

       58
       +
       ```bash

     

       59
       +
       # Doggo automatically detects workspace configuration

     

       60
       +
       doggo

     

       61
       +
       

     

       62
       +
       # Force workspace mode

     

       63
       +
       doggo --workspace

     

       64
       +
       ```

     

       65
       +
       

     

       66
       +
       ### 🦴 Using with Deno Tasks

     

       67
       +
       

     

       68
       +
       Add to your `deno.json`:

     

       69
       +
       ```json

     

       70
       +
       {

     

       71
       +
         "tasks": {

     

       72
       +
           "doc:check": "doggo",

     

       73
       +
           "doc:check:workspace": "doggo --workspace"

     

       74
       +
         }

     

       75
       +
       }

     

       76
       +
       ```

     

       77
       +
       

     

       78
       +
       Then run:

     

       79
       +
       ```bash

     

       80
       +
       deno task doc:check

     

       81
       +
       ```

     

       82
       +
       

     

       83
       +
       ## 🐕 Commands & Options

     

       84
       +
       

     

       85
       +
       ```

     

       86
       +
       Doggo - JSDoc Coverage Analyzer for Good Boys and Girls

     

       87
       +
       

     

       88
       +
       Usage:

     

       89
       +
         doggo [options] [path]

     

       90
       +
       

     

       91
       +
       Options:

     

       92
       +
         -h, --help      Show help (Doggo does tricks!)

     

       93
       +
         -v, --version   Show version (Doggo's age in dog years)

     

       94
       +
         -p, --path      Path to analyze (where should Doggo sniff?)

     

       95
       +
         -w, --workspace Force workspace mode (analyze the whole pack!)

     

       96
       +
       

     

       97
       +
       Examples:

     

       98
       +
         doggo                           # Analyze current directory

     

       99
       +
         doggo ./src                     # Analyze specific directory

     

       100
       +
         doggo ./src/module.ts          # Analyze single file

     

       101
       +
         doggo --workspace              # Analyze all workspace members

     

       102
       +
       ```

     

       103
       +
       

     

       104
       +
       ## 🎯 What Doggo Analyzes

     

       105
       +
       

     

       106
       +
       ### 🏢 Workspace Mode (The Pack)

     

       107
       +
       When Doggo finds a `workspace` field in `deno.json`:

     

       108
       +
       - Analyzes each pack member individually

     

       109
       +
       - Provides per-member documentation statistics

     

       110
       +
       - Shows aggregate statistics for the entire pack

     

       111
       +
       - Barks at members that need documentation improvements

     

       112
       +
       

     

       113
       +
       ### 🎯 Smart Mode (Following the Scent)

     

       114
       +
       When a `deno.json` or `deno.jsonc` file with an `exports` field is found:

     

       115
       +
       - Traces the actual public API from the entry point(s)

     

       116
       +
       - Only analyzes symbols that users actually see

     

       117
       +
       - Ignores internal implementation (no digging in the backyard!)

     

       118
       +
       - Provides accurate coverage for your public API

     

       119
       +
       

     

       120
       +
       ### 🔍 Full Analysis Mode (Sniffing Everything)

     

       121
       +
       When no `deno.json` with exports is found:

     

       122
       +
       - Analyzes all exported symbols in the codebase

     

       123
       +
       - Comprehensive coverage reporting

     

       124
       +
       - Great for internal packages or during development

     

       125
       +
       

     

       126
       +
       ### 📦 Supported Exports

     

       127
       +
       

     

       128
       +
       Doggo can detect and analyze:

     

       129
       +
       - **Functions** - Regular functions, async functions, arrow functions

     

       130
       +
       - **Classes** - Class declarations with their methods

     

       131
       +
       - **Interfaces** - TypeScript interface definitions

     

       132
       +
       - **Types** - Type aliases and type definitions

     

       133
       +
       - **Constants** - Exported const declarations

     

       134
       +
       - **Variables** - Exported let/var declarations

     

       135
       +
       - **Enums** - TypeScript enum definitions

     

       136
       +
       - **Default Exports** - Default exported symbols

     

       137
       +
       

     

       138
       +
       ### 🚫 What Doggo Ignores

     

       139
       +
       

     

       140
       +
       Good boys know not to dig in:

     

       141
       +
       - `node_modules/` directory

     

       142
       +
       - `.git/` directory

     

       143
       +
       - `dist/`, `build/`, `coverage/` directories

     

       144
       +
       - Test files (`*.test.*`, `*.spec.*`, `test/`, `tests/`, `*_test.*`)

     

       145
       +
       

     

       146
       +
       ## 🎨 Example Output

     

       147
       +
       

     

       148
       +
       ### Single Package (Good Boy Mode)

     

       149
       +
       ```

     

       150
       +
       🐶 Analyzing Deno Package Documentation Coverage

     

       151
       +
       

     

       152
       +
       Path: /path/to/your/package

     

       153
       +
       

     

       154
       +
       Found deno.json with exports: ./mod.ts

     

       155
       +
       

     

       156
       +
       Sniffing out public API from export entry points...

     

       157
       +
       

     

       158
       +
       📝 Undocumented Exports (Doggo found these!):

     

       159
       +
       

     

       160
       +
         src/utils.ts:

     

       161
       +
           ✗ formatDate [function]:67

     

       162
       +
       

     

       163
       +
         mod.ts:

     

       164
       +
           ✗ LogLevel [type]:45

     

       165
       +
       

     

       166
       +
       📊 Documentation Coverage Summary

     

       167
       +
       

     

       168
       +
       ──────────────────────────────────────────────────

     

       169
       +
         Total Exports:     8

     

       170
       +
         Documented:        6

     

       171
       +
         Undocumented:      2

     

       172
       +
         Coverage:          75%

     

       173
       +
       ──────────────────────────────────────────────────

     

       174
       +
       

     

       175
       +
         📈 Documentation needs improvement (Doggo wants treats!)

     

       176
       +
       ```

     

       177
       +
       

     

       178
       +
       ### Workspace Analysis (Pack Report)

     

       179
       +
       ```

     

       180
       +
       🏢 Analyzing Deno Workspace (The Pack!)

     

       181
       +
       

     

       182
       +
       Root: /path/to/workspace

     

       183
       +
       Members: 3

     

       184
       +
       

     

       185
       +
       🐕 Analyzing common...

     

       186
       +
         ⚡ common                10 exports, 60% documented

     

       187
       +
           └─ Entry: ./mod.ts

     

       188
       +
       

     

       189
       +
       🐕 Analyzing bytes...

     

       190
       +
         ✗ bytes                 14 exports, 50% documented

     

       191
       +
           └─ Entry: ./mod.ts

     

       192
       +
       

     

       193
       +
       📊 Pack Summary

     

       194
       +
       ────────────────────────────────────────────────────────────

     

       195
       +
         Overall Statistics:

     

       196
       +
           Total Members:     3

     

       197
       +
           Total Exports:     37

     

       198
       +
           Documented:        20

     

       199
       +
           Coverage:          54%

     

       200
       +
       

     

       201
       +
         ⚠️  Pack members needing training:

     

       202
       +
           - bytes (50%)

     

       203
       +
       

     

       204
       +
         ⚠️  The pack needs better documentation!

     

       205
       +
       ```

     

       206
       +
       

     

       207
       +
       ## 🏆 Coverage Indicators

     

       208
       +
       

     

       209
       +
       Doggo's tail wags differently based on your coverage:

     

       210
       +
       

     

       211
       +
       - 🏆 **100%** - Perfect! Doggo is doing zoomies!

     

       212
       +
       - ✨ **90-99%** - Excellent! Tail wagging intensifies!

     

       213
       +
       - 👍 **80-89%** - Good boy! Happy tail wags

     

       214
       +
       - 📈 **60-79%** - Needs improvement (Doggo is concerned)

     

       215
       +
       - ⚠️ **40-59%** - Poor coverage (Sad puppy eyes)

     

       216
       +
       - 🚨 **0-39%** - Critical! (Doggo is hiding under the bed)

     

       217
       +
       

     

       218
       +
       ## 💡 JSDoc Examples

     

       219
       +
       

     

       220
       +
       ### ✅ Good Boy (Documented)

     

       221
       +
       ```typescript

     

       222
       +
       /**

     

       223
       +
        * Calculates the number of dog treats needed.

     

       224
       +
        * @param dogs The number of dogs

     

       225
       +
        * @param treatsPerDog Treats each dog should get

     

       226
       +
        * @returns Total number of treats needed

     

       227
       +
        */

     

       228
       +
       export function calculateTreats(dogs: number, treatsPerDog: number): number {

     

       229
       +
         return dogs * treatsPerDog;

     

       230
       +
       }

     

       231
       +
       ```

     

       232
       +
       

     

       233
       +
       ### ❌ Bad Boy (Needs Documentation)

     

       234
       +
       ```typescript

     

       235
       +
       export function calculateTreats(dogs: number, treatsPerDog: number): number {

     

       236
       +
         return dogs * treatsPerDog;

     

       237
       +
       }

     

       238
       +
       ```

     

       239
       +
       

     

       240
       +
       ## 🔧 How Doggo Works

     

       241
       +
       

     

       242
       +
       ### When sniffing a workspace:

     

       243
       +
       1. **Detect Pack** - Reads `deno.json` to find workspace members

     

       244
       +
       2. **Analyze Each Member** - Individually checks each pack member

     

       245
       +
       3. **Aggregate Results** - Combines statistics across all members

     

       246
       +
       4. **Generate Report** - Shows both individual and pack-wide metrics

     

       247
       +
       

     

       248
       +
       ### When following an exports scent:

     

       249
       +
       1. **Load Configuration** - Reads `deno.json` to find the `exports` field

     

       250
       +
       2. **Trace Public API** - Follows all re-exports and direct exports

     

       251
       +
       3. **Symbol Resolution** - Tracks `export { ... } from` statements

     

       252
       +
       4. **JSDoc Detection** - Checks for JSDoc comments on source definitions

     

       253
       +
       5. **Report Generation** - Shows only public API symbols

     

       254
       +
       

     

       255
       +
       ### When sniffing everything:

     

       256
       +
       1. **File Discovery** - Recursively finds all source files

     

       257
       +
       2. **Export Detection** - Identifies all exported symbols

     

       258
       +
       3. **JSDoc Detection** - Checks for JSDoc comments above exports

     

       259
       +
       4. **Statistics Calculation** - Computes coverage percentages

     

       260
       +
       5. **Report Generation** - Outputs formatted report

     

       261
       +
       

     

       262
       +
       ## 🦴 Configuration

     

       263
       +
       

     

       264
       +
       ### Working with deno.json

     

       265
       +
       

     

       266
       +
       Doggo automatically detects your configuration:

     

       267
       +
       

     

       268
       +
       ```json

     

       269
       +
       {

     

       270
       +
         "name": "@your-org/package",

     

       271
       +
         "version": "1.0.0",

     

       272
       +
         "exports": "./mod.ts"

     

       273
       +
       }

     

       274
       +
       ```

     

       275
       +
       

     

       276
       +
       When an `exports` field is present, Doggo only analyzes symbols exported through that entry point.

     

       277
       +
       

     

       278
       +
       ### Working with Workspaces

     

       279
       +
       

     

       280
       +
       For multi-package repositories:

     

       281
       +
       

     

       282
       +
       ```json

     

       283
       +
       {

     

       284
       +
         "workspace": [

     

       285
       +
           "packages/core",

     

       286
       +
           "packages/utils",

     

       287
       +
           "packages/cli"

     

       288
       +
         ]

     

       289
       +
       }

     

       290
       +
       ```

     

       291
       +
       

     

       292
       +
       Doggo will analyze each member independently and provide aggregate statistics.

     

       293
       +
       

     

       294
       +
       ## 🐾 Tips & Tricks

     

       295
       +
       

     

       296
       +
       1. **Start with exports** - Use `deno.json` exports field to focus on your public API

     

       297
       +
       2. **Document as you code** - It's easier to document while the code is fresh

     

       298
       +
       3. **Use meaningful descriptions** - Help users understand not just what, but why

     

       299
       +
       4. **Include examples** - Show how to use your functions

     

       300
       +
       5. **Check regularly** - Add Doggo to your CI/CD pipeline

     

       301
       +
       

     

       302
       +
       ## 🤝 Contributing

     

       303
       +
       

     

       304
       +
       Doggo loves new friends! Feel free to:

     

       305
       +
       - Report bugs (Doggo doesn't like fleas!)

     

       306
       +
       - Suggest new features (Teach Doggo new tricks!)

     

       307
       +
       - Submit pull requests (Bring treats!)

     

       308
       +
       - Improve documentation (Help Doggo communicate better!)

     

       309
       +
       

     

       310
       +
       ## 📄 License

     

       311
       +
       

     

       312
       +
       MIT License - Doggo is free to roam and play!

     

       313
       +
       

     

       314
       +
       ## 🙏 Acknowledgments

     

       315
       +
       

     

       316
       +
       - Built with ❤️ and 🦴 for the Deno community

     

       317
       +
       - Inspired by good boys and girls everywhere

     

       318
       +
       - Special thanks to all contributors who helped train Doggo

     

       319
       +
       

     

       320
       +
       ## 🐕 Why "Doggo"?

     

       321
       +
       

     

       322
       +
       Because good dogs always document their code! Plus, who doesn't love a coding companion that:

     

       323
       +
       - Never judges your code (only helps improve it)

     

       324
       +
       - Is always excited to help

     

       325
       +
       - Loyally guards your documentation quality

     

       326
       +
       - Makes coding more fun!

     

       327
       +
       

     

       328
       +
       ---

     

       329
       +
       

     

       330
       +
       *Woof! Happy documenting!* 🐶

     

       331
       +
       

     

       332
       +
       **Remember:** A well-documented codebase is like a well-trained dog - everyone loves playing with it!

+866

core.ts

···

       1
       +
       /**

     

       2
       +
        * Core module for JSDoc coverage analysis

     

       3
       +
        * @module

     

       4
       +
        */

     

       5
       +
       

     

       6
       +
       import { walk } from "@std/fs";

     

       7
       +
       import { dirname, join, relative, resolve } from "@std/path";

     

       8
       +
       

     

       9
       +
       export interface ExportedSymbol {

     

       10
       +
         name: string;

     

       11
       +
         type:

     

       12
       +
           | "function"

     

       13
       +
           | "class"

     

       14
       +
           | "interface"

     

       15
       +
           | "type"

     

       16
       +
           | "const"

     

       17
       +
           | "variable"

     

       18
       +
           | "enum";

     

       19
       +
         file: string;

     

       20
       +
         line: number;

     

       21
       +
         hasJSDoc: boolean;

     

       22
       +
         jsDocContent?: string;

     

       23
       +
         exportType: "named" | "default";

     

       24
       +
       }

     

       25
       +
       

     

       26
       +
       export interface DocumentationStats {

     

       27
       +
         total: number;

     

       28
       +
         documented: number;

     

       29
       +
         undocumented: number;

     

       30
       +
         percentage: number;

     

       31
       +
         byType: Record<string, { total: number; documented: number }>;

     

       32
       +
       }

     

       33
       +
       

     

       34
       +
       export interface AnalysisResult {

     

       35
       +
         path: string;

     

       36
       +
         hasDenoJson: boolean;

     

       37
       +
         hasExports: boolean;

     

       38
       +
         exportPath?: string;

     

       39
       +
         symbols: ExportedSymbol[];

     

       40
       +
         stats: DocumentationStats;

     

       41
       +
       }

     

       42
       +
       

     

       43
       +
       interface DenoConfig {

     

       44
       +
         exports?: string | Record<string, string>;

     

       45
       +
         name?: string;

     

       46
       +
         version?: string;

     

       47
       +
       }

     

       48
       +
       

     

       49
       +
       interface TracedExport {

     

       50
       +
         originalName: string;

     

       51
       +
         exportedName: string;

     

       52
       +
         sourcePath: string;

     

       53
       +
         line: number;

     

       54
       +
       }

     

       55
       +
       

     

       56
       +
       /**

     

       57
       +
        * Analyzes a directory or file for JSDoc coverage.

     

       58
       +
        * @param targetPath The path to analyze

     

       59
       +
        * @returns Analysis results including symbols and statistics

     

       60
       +
        */

     

       61
       +
       export async function analyzeDirectory(

     

       62
       +
         targetPath: string,

     

       63
       +
       ): Promise<AnalysisResult> {

     

       64
       +
         const rootPath = resolve(targetPath);

     

       65
       +
         const symbols: ExportedSymbol[] = [];

     

       66
       +
         const analyzedFiles = new Set<string>();

     

       67
       +
         const exportMap = new Map<string, TracedExport[]>();

     

       68
       +
       

     

       69
       +
         // Check for deno.json

     

       70
       +
         const denoConfig = await loadDenoConfig(rootPath);

     

       71
       +
         const hasDenoJson = denoConfig !== null;

     

       72
       +
         const hasExports = !!(denoConfig?.exports);

     

       73
       +
         const exportPath = typeof denoConfig?.exports === "string"

     

       74
       +
           ? denoConfig.exports

     

       75
       +
           : denoConfig?.exports

     

       76
       +
           ? Object.values(denoConfig.exports)[0]

     

       77
       +
           : undefined;

     

       78
       +
       

     

       79
       +
         if (denoConfig?.exports) {

     

       80
       +
           // Use exports field as entry point

     

       81
       +
           await analyzeFromExports(

     

       82
       +
             rootPath,

     

       83
       +
             denoConfig.exports,

     

       84
       +
             symbols,

     

       85
       +
             analyzedFiles,

     

       86
       +
             exportMap,

     

       87
       +
           );

     

       88
       +
         } else {

     

       89
       +
           // Fall back to analyzing all files

     

       90
       +
           await analyzeAllFiles(rootPath, symbols);

     

       91
       +
         }

     

       92
       +
       

     

       93
       +
         // Calculate statistics

     

       94
       +
         const stats = calculateStats(symbols);

     

       95
       +
       

     

       96
       +
         return {

     

       97
       +
           path: rootPath,

     

       98
       +
           hasDenoJson,

     

       99
       +
           hasExports,

     

       100
       +
           exportPath,

     

       101
       +
           symbols,

     

       102
       +
           stats,

     

       103
       +
         };

     

       104
       +
       }

     

       105
       +
       

     

       106
       +
       async function loadDenoConfig(rootPath: string): Promise<DenoConfig | null> {

     

       107
       +
         // Check if rootPath is a file

     

       108
       +
         const stat = await Deno.stat(rootPath);

     

       109
       +
         if (stat.isFile) {

     

       110
       +
           // If analyzing a single file, check parent directory for deno.json

     

       111
       +
           rootPath = dirname(rootPath);

     

       112
       +
         }

     

       113
       +
       

     

       114
       +
         const configPath = join(rootPath, "deno.json");

     

       115
       +
         try {

     

       116
       +
           const configContent = await Deno.readTextFile(configPath);

     

       117
       +
           const config = JSON.parse(configContent) as DenoConfig;

     

       118
       +
           return config;

     

       119
       +
         } catch {

     

       120
       +
           // Try deno.jsonc

     

       121
       +
           const configPathJsonc = join(rootPath, "deno.jsonc");

     

       122
       +
           try {

     

       123
       +
             const configContent = await Deno.readTextFile(configPathJsonc);

     

       124
       +
             // Simple JSONC parsing - remove comments

     

       125
       +
             const jsonContent = configContent

     

       126
       +
               .split("\n")

     

       127
       +
               .map((line) => {

     

       128
       +
                 const commentIndex = line.indexOf("//");

     

       129
       +
                 return commentIndex > -1 ? line.slice(0, commentIndex) : line;

     

       130
       +
               })

     

       131
       +
               .join("\n")

     

       132
       +
               .replace(/\/\*[\s\S]*?\*\//g, "");

     

       133
       +
             const config = JSON.parse(jsonContent) as DenoConfig;

     

       134
       +
             return config;

     

       135
       +
           } catch {

     

       136
       +
             return null;

     

       137
       +
           }

     

       138
       +
         }

     

       139
       +
       }

     

       140
       +
       

     

       141
       +
       async function analyzeFromExports(

     

       142
       +
         rootPath: string,

     

       143
       +
         exports: string | Record<string, string>,

     

       144
       +
         symbols: ExportedSymbol[],

     

       145
       +
         analyzedFiles: Set<string>,

     

       146
       +
         exportMap: Map<string, TracedExport[]>,

     

       147
       +
       ): Promise<void> {

     

       148
       +
         // Handle string or object exports

     

       149
       +
         const exportPaths: string[] = [];

     

       150
       +
       

     

       151
       +
         if (typeof exports === "string") {

     

       152
       +
           exportPaths.push(exports);

     

       153
       +
         } else {

     

       154
       +
           // For object exports, analyze all export paths

     

       155
       +
           exportPaths.push(...Object.values(exports));

     

       156
       +
         }

     

       157
       +
       

     

       158
       +
         for (const exportPath of exportPaths) {

     

       159
       +
           const fullPath = join(rootPath, exportPath);

     

       160
       +
           await traceExportsFromFile(

     

       161
       +
             fullPath,

     

       162
       +
             analyzedFiles,

     

       163
       +
             exportMap,

     

       164
       +
             rootPath,

     

       165
       +
           );

     

       166
       +
         }

     

       167
       +
       

     

       168
       +
         // Now analyze JSDoc for all traced symbols

     

       169
       +
         for (const [_filePath, exports] of exportMap.entries()) {

     

       170
       +
           await analyzeFileForJSDoc(exports, symbols, rootPath);

     

       171
       +
         }

     

       172
       +
       }

     

       173
       +
       

     

       174
       +
       async function traceExportsFromFile(

     

       175
       +
         filePath: string,

     

       176
       +
         analyzedFiles: Set<string>,

     

       177
       +
         exportMap: Map<string, TracedExport[]>,

     

       178
       +
         rootPath: string,

     

       179
       +
       ): Promise<void> {

     

       180
       +
         if (analyzedFiles.has(filePath)) {

     

       181
       +
           return;

     

       182
       +
         }

     

       183
       +
         analyzedFiles.add(filePath);

     

       184
       +
       

     

       185
       +
         try {

     

       186
       +
           const content = await Deno.readTextFile(filePath);

     

       187
       +
           const lines = content.split("\n");

     

       188
       +
           const currentDir = dirname(filePath);

     

       189
       +
       

     

       190
       +
           for (let i = 0; i < lines.length; i++) {

     

       191
       +
             const line = lines[i];

     

       192
       +
             const trimmed = line.trim();

     

       193
       +
       

     

       194
       +
             // Handle re-exports: export * from "./module.ts" or export { ... } from "./module.ts" or export type { ... } from "./module.ts"

     

       195
       +
             if (

     

       196
       +
               trimmed.startsWith("export *") || trimmed.startsWith("export {") ||

     

       197
       +
               trimmed.startsWith("export type {")

     

       198
       +
             ) {

     

       199
       +
               const fromMatch = trimmed.match(/from\s+["']([^"']+)["']/);

     

       200
       +
               if (fromMatch) {

     

       201
       +
                 // Re-export with from clause

     

       202
       +
                 const importPath = fromMatch[1];

     

       203
       +
                 const resolvedPath = await resolveImportPath(importPath, currentDir);

     

       204
       +
                 if (resolvedPath) {

     

       205
       +
                   // If it's export *, we need to find all exports from that file

     

       206
       +
                   if (trimmed.startsWith("export *")) {

     

       207
       +
                     // For export *, we need to recursively trace that file

     

       208
       +
                     await traceExportsFromFile(

     

       209
       +
                       resolvedPath,

     

       210
       +
                       analyzedFiles,

     

       211
       +
                       exportMap,

     

       212
       +
                       rootPath,

     

       213
       +
                     );

     

       214
       +
                     // Copy all exports from that file

     

       215
       +
                     const sourceExports = exportMap.get(resolvedPath) || [];

     

       216
       +
                     for (const exp of sourceExports) {

     

       217
       +
                       addExport(exportMap, filePath, {

     

       218
       +
                         ...exp,

     

       219
       +
                         exportedName: exp.exportedName,

     

       220
       +
                       });

     

       221
       +
                     }

     

       222
       +
                   } else {

     

       223
       +
                     // Handle selective re-exports: export { a, b as c } from "./module" or export type { ... } from "./module"

     

       224
       +
                     const exportsMatch = trimmed.match(

     

       225
       +
                       /export\s*(?:type\s+)?{\s*([^}]+)\s*}/,

     

       226
       +
                     );

     

       227
       +
                     if (exportsMatch) {

     

       228
       +
                       const exportsList = exportsMatch[1].split(",").map((e) =>

     

       229
       +
                         e.trim()

     

       230
       +
                       );

     

       231
       +
       

     

       232
       +
                       // For selective exports, only track the specific symbols

     

       233
       +
                       for (const exportItem of exportsList) {

     

       234
       +
                         const [originalName, exportedName] = exportItem

     

       235
       +
                           .split(/\s+as\s+/)

     

       236
       +
                           .map((s) => s.trim());

     

       237
       +
       

     

       238
       +
                         // Find the line number in the source file where this symbol is defined

     

       239
       +
                         const lineNum = await findSymbolInFile(

     

       240
       +
                           resolvedPath,

     

       241
       +
                           originalName,

     

       242
       +
                         );

     

       243
       +
       

     

       244
       +
                         addExport(exportMap, filePath, {

     

       245
       +
                           originalName,

     

       246
       +
                           exportedName: exportedName || originalName,

     

       247
       +
                           sourcePath: resolvedPath,

     

       248
       +
                           line: lineNum || i + 1,

     

       249
       +
                         });

     

       250
       +
                       }

     

       251
       +
                     }

     

       252
       +
                   }

     

       253
       +
                 }

     

       254
       +
               } else if (

     

       255
       +
                 trimmed.startsWith("export {") || trimmed.startsWith("export type {")

     

       256
       +
               ) {

     

       257
       +
                 // Export without from clause (e.g., export { foo, bar } or export type { foo })

     

       258
       +
                 // These are re-exports of previously imported symbols

     

       259
       +
                 const exportsMatch = trimmed.match(

     

       260
       +
                   /export\s*(?:type\s+)?{\s*([^}]+)\s*}/,

     

       261
       +
                 );

     

       262
       +
                 if (exportsMatch) {

     

       263
       +
                   const exportsList = exportsMatch[1].split(",").map((e) => e.trim());

     

       264
       +
       

     

       265
       +
                   for (const exportItem of exportsList) {

     

       266
       +
                     const [originalName, exportedName] = exportItem

     

       267
       +
                       .split(/\s+as\s+/)

     

       268
       +
                       .map((s) => s.trim());

     

       269
       +
       

     

       270
       +
                     // For import-then-export pattern, we need to find where these were imported from

     

       271
       +
                     const importSource = await findImportSource(

     

       272
       +
                       content,

     

       273
       +
                       originalName,

     

       274
       +
                       currentDir,

     

       275
       +
                     );

     

       276
       +
       

     

       277
       +
                     if (importSource) {

     

       278
       +
                       // Found the import source, trace that file

     

       279
       +
                       const lineNum = await findSymbolInFile(

     

       280
       +
                         importSource,

     

       281
       +
                         originalName,

     

       282
       +
                       );

     

       283
       +
       

     

       284
       +
                       addExport(exportMap, filePath, {

     

       285
       +
                         originalName,

     

       286
       +
                         exportedName: exportedName || originalName,

     

       287
       +
                         sourcePath: importSource,

     

       288
       +
                         line: lineNum || i + 1,

     

       289
       +
                       });

     

       290
       +
                     } else {

     

       291
       +
                       // Treat as a local export if we can't find the import

     

       292
       +
                       addExport(exportMap, filePath, {

     

       293
       +
                         originalName,

     

       294
       +
                         exportedName: exportedName || originalName,

     

       295
       +
                         sourcePath: filePath,

     

       296
       +
                         line: i + 1,

     

       297
       +
                       });

     

       298
       +
                     }

     

       299
       +
                   }

     

       300
       +
                 }

     

       301
       +
               }

     

       302
       +
             } // Handle direct exports in this file

     

       303
       +
             else if (isDirectExport(trimmed)) {

     

       304
       +
               const symbolName = extractExportName(trimmed);

     

       305
       +
               if (symbolName) {

     

       306
       +
                 addExport(exportMap, filePath, {

     

       307
       +
                   originalName: symbolName,

     

       308
       +
                   exportedName: symbolName,

     

       309
       +
                   sourcePath: filePath,

     

       310
       +
                   line: i + 1,

     

       311
       +
                 });

     

       312
       +
               }

     

       313
       +
             }

     

       314
       +
           }

     

       315
       +
         } catch {

     

       316
       +
           // Silently ignore errors for missing files

     

       317
       +
         }

     

       318
       +
       }

     

       319
       +
       

     

       320
       +
       async function findImportSource(

     

       321
       +
         fileContent: string,

     

       322
       +
         symbolName: string,

     

       323
       +
         currentDir: string,

     

       324
       +
       ): Promise<string | null> {

     

       325
       +
         const lines = fileContent.split("\n");

     

       326
       +
       

     

       327
       +
         for (const line of lines) {

     

       328
       +
           const trimmed = line.trim();

     

       329
       +
       

     

       330
       +
           // Look for import statements

     

       331
       +
           if (trimmed.startsWith("import ")) {

     

       332
       +
             // Check for named imports: import { symbolName } from "..."

     

       333
       +
             const namedImportMatch = trimmed.match(

     

       334
       +
               /import\s*{([^}]+)}\s*from\s*["']([^"']+)["']/,

     

       335
       +
             );

     

       336
       +
       

     

       337
       +
             if (namedImportMatch) {

     

       338
       +
               const imports = namedImportMatch[1].split(",").map((i) => i.trim());

     

       339
       +
       

     

       340
       +
               for (const imp of imports) {

     

       341
       +
                 const [imported, alias] = imp.split(/\s+as\s+/).map((s) => s.trim());

     

       342
       +
       

     

       343
       +
                 // Check if this import includes our symbol

     

       344
       +
                 if (imported === symbolName || alias === symbolName) {

     

       345
       +
                   const importPath = namedImportMatch[2];

     

       346
       +
                   return await resolveImportPath(importPath, currentDir);

     

       347
       +
                 }

     

       348
       +
               }

     

       349
       +
             }

     

       350
       +
       

     

       351
       +
             // Check for default import: import symbolName from "..."

     

       352
       +
             const defaultImportMatch = trimmed.match(

     

       353
       +
               /import\s+(\w+)\s+from\s*["']([^"']+)["']/,

     

       354
       +
             );

     

       355
       +
       

     

       356
       +
             if (defaultImportMatch && defaultImportMatch[1] === symbolName) {

     

       357
       +
               const importPath = defaultImportMatch[2];

     

       358
       +
               return await resolveImportPath(importPath, currentDir);

     

       359
       +
             }

     

       360
       +
       

     

       361
       +
             // Check for namespace import: import * as symbolName from "..."

     

       362
       +
             const namespaceImportMatch = trimmed.match(

     

       363
       +
               /import\s*\*\s+as\s+(\w+)\s+from\s*["']([^"']+)["']/,

     

       364
       +
             );

     

       365
       +
       

     

       366
       +
             if (namespaceImportMatch && namespaceImportMatch[1] === symbolName) {

     

       367
       +
               const importPath = namespaceImportMatch[2];

     

       368
       +
               return await resolveImportPath(importPath, currentDir);

     

       369
       +
             }

     

       370
       +
           }

     

       371
       +
         }

     

       372
       +
       

     

       373
       +
         return null;

     

       374
       +
       }

     

       375
       +
       

     

       376
       +
       async function resolveImportPath(

     

       377
       +
         importPath: string,

     

       378
       +
         fromDir: string,

     

       379
       +
       ): Promise<string | null> {

     

       380
       +
         // Handle relative imports

     

       381
       +
         if (importPath.startsWith(".")) {

     

       382
       +
           const basePath = join(fromDir, importPath);

     

       383
       +
       

     

       384
       +
           // Try with common extensions

     

       385
       +
           const extensions = [

     

       386
       +
             ".ts",

     

       387
       +
             ".tsx",

     

       388
       +
             ".js",

     

       389
       +
             ".jsx",

     

       390
       +
             ".mjs",

     

       391
       +
             "/mod.ts",

     

       392
       +
             "/index.ts",

     

       393
       +
           ];

     

       394
       +
       

     

       395
       +
           // First try exact path

     

       396
       +
           try {

     

       397
       +
             await Deno.stat(basePath);

     

       398
       +
             return resolve(basePath);

     

       399
       +
           } catch {

     

       400
       +
             // Try with extensions

     

       401
       +
             for (const ext of extensions) {

     

       402
       +
               try {

     

       403
       +
                 const fullPath = basePath.endsWith(".ts") || basePath.endsWith(".js")

     

       404
       +
                   ? basePath

     

       405
       +
                   : basePath + ext;

     

       406
       +
                 await Deno.stat(fullPath);

     

       407
       +
                 return resolve(fullPath);

     

       408
       +
               } catch {

     

       409
       +
                 continue;

     

       410
       +
               }

     

       411
       +
             }

     

       412
       +
           }

     

       413
       +
         }

     

       414
       +
       

     

       415
       +
         return null;

     

       416
       +
       }

     

       417
       +
       

     

       418
       +
       async function findSymbolInFile(

     

       419
       +
         filePath: string,

     

       420
       +
         symbolName: string,

     

       421
       +
       ): Promise<number | null> {

     

       422
       +
         try {

     

       423
       +
           const content = await Deno.readTextFile(filePath);

     

       424
       +
           const lines = content.split("\n");

     

       425
       +
       

     

       426
       +
           for (let i = 0; i < lines.length; i++) {

     

       427
       +
             const line = lines[i].trim();

     

       428
       +
       

     

       429
       +
             // Check if this line exports the symbol we're looking for

     

       430
       +
             if (isDirectExport(line)) {

     

       431
       +
               const exportedName = extractExportName(line);

     

       432
       +
               if (exportedName === symbolName) {

     

       433
       +
                 return i + 1;

     

       434
       +
               }

     

       435
       +
             }

     

       436
       +
           }

     

       437
       +
         } catch {

     

       438
       +
           // Ignore errors

     

       439
       +
         }

     

       440
       +
       

     

       441
       +
         return null;

     

       442
       +
       }

     

       443
       +
       

     

       444
       +
       function isDirectExport(line: string): boolean {

     

       445
       +
         return (

     

       446
       +
           line.startsWith("export function") ||

     

       447
       +
           line.startsWith("export async function") ||

     

       448
       +
           line.startsWith("export class") ||

     

       449
       +
           line.startsWith("export interface") ||

     

       450
       +
           line.startsWith("export type") ||

     

       451
       +
           line.startsWith("export enum") ||

     

       452
       +
           line.startsWith("export const") ||

     

       453
       +
           line.startsWith("export let") ||

     

       454
       +
           line.startsWith("export var") ||

     

       455
       +
           line.startsWith("export default")

     

       456
       +
         );

     

       457
       +
       }

     

       458
       +
       

     

       459
       +
       function extractExportName(line: string): string | null {

     

       460
       +
         // Extract the symbol name from various export patterns

     

       461
       +
         const patterns = [

     

       462
       +
           /export\s+(?:async\s+)?function\s+(\w+)/,

     

       463
       +
           /export\s+class\s+(\w+)/,

     

       464
       +
           /export\s+interface\s+(\w+)/,

     

       465
       +
           /export\s+type\s+(\w+)/,

     

       466
       +
           /export\s+enum\s+(\w+)/,

     

       467
       +
           /export\s+(?:const|let|var)\s+(\w+)/,

     

       468
       +
         ];

     

       469
       +
       

     

       470
       +
         for (const pattern of patterns) {

     

       471
       +
           const match = line.match(pattern);

     

       472
       +
           if (match) {

     

       473
       +
             return match[1];

     

       474
       +
           }

     

       475
       +
         }

     

       476
       +
       

     

       477
       +
         if (line.includes("export default")) {

     

       478
       +
           return "default";

     

       479
       +
         }

     

       480
       +
       

     

       481
       +
         return null;

     

       482
       +
       }

     

       483
       +
       

     

       484
       +
       function addExport(

     

       485
       +
         exportMap: Map<string, TracedExport[]>,

     

       486
       +
         filePath: string,

     

       487
       +
         exportInfo: TracedExport,

     

       488
       +
       ): void {

     

       489
       +
         if (!exportMap.has(filePath)) {

     

       490
       +
           exportMap.set(filePath, []);

     

       491
       +
         }

     

       492
       +
       

     

       493
       +
         // Avoid duplicates

     

       494
       +
         const existing = exportMap.get(filePath)!;

     

       495
       +
         const isDuplicate = existing.some(

     

       496
       +
           (e) =>

     

       497
       +
             e.exportedName === exportInfo.exportedName &&

     

       498
       +
             e.sourcePath === exportInfo.sourcePath,

     

       499
       +
         );

     

       500
       +
       

     

       501
       +
         if (!isDuplicate) {

     

       502
       +
           existing.push(exportInfo);

     

       503
       +
         }

     

       504
       +
       }

     

       505
       +
       

     

       506
       +
       async function analyzeFileForJSDoc(

     

       507
       +
         exports: TracedExport[],

     

       508
       +
         symbols: ExportedSymbol[],

     

       509
       +
         rootPath: string,

     

       510
       +
       ): Promise<void> {

     

       511
       +
         // Group exports by their source file

     

       512
       +
         const exportsBySource = new Map<string, TracedExport[]>();

     

       513
       +
         for (const exp of exports) {

     

       514
       +
           if (!exportsBySource.has(exp.sourcePath)) {

     

       515
       +
             exportsBySource.set(exp.sourcePath, []);

     

       516
       +
           }

     

       517
       +
           exportsBySource.get(exp.sourcePath)!.push(exp);

     

       518
       +
         }

     

       519
       +
       

     

       520
       +
         // Analyze each source file

     

       521
       +
         for (const [sourcePath, sourceExports] of exportsBySource.entries()) {

     

       522
       +
           try {

     

       523
       +
             const content = await Deno.readTextFile(sourcePath);

     

       524
       +
             const lines = content.split("\n");

     

       525
       +
             const relativePath = relative(rootPath, sourcePath);

     

       526
       +
       

     

       527
       +
             // Track JSDoc blocks

     

       528
       +
             const jsDocBlocks: Map<number, string> = new Map();

     

       529
       +
             let currentJSDoc: string[] = [];

     

       530
       +
       

     

       531
       +
             for (let i = 0; i < lines.length; i++) {

     

       532
       +
               const line = lines[i];

     

       533
       +
               const trimmed = line.trim();

     

       534
       +
       

     

       535
       +
               // Track JSDoc blocks

     

       536
       +
               if (trimmed.startsWith("/**")) {

     

       537
       +
                 currentJSDoc = [trimmed];

     

       538
       +
               } else if (currentJSDoc.length > 0) {

     

       539
       +
                 currentJSDoc.push(line);

     

       540
       +
                 if (trimmed.endsWith("*/")) {

     

       541
       +
                   // JSDoc block complete, associate with next code line

     

       542
       +
                   const jsDocContent = currentJSDoc.join("\n");

     

       543
       +
                   // Skip module-level JSDoc (contains @module tag)

     

       544
       +
                   if (jsDocContent.includes("@module")) {

     

       545
       +
                     currentJSDoc = [];

     

       546
       +
                     continue;

     

       547
       +
                   }

     

       548
       +
                   // Find the next line that starts an export declaration

     

       549
       +
                   for (let j = i + 1; j < lines.length; j++) {

     

       550
       +
                     const nextLine = lines[j].trim();

     

       551
       +
                     if (nextLine && !nextLine.startsWith("//")) {

     

       552
       +
                       // Only associate JSDoc with export declarations

     

       553
       +
                       if (

     

       554
       +
                         isDirectExport(nextLine) || nextLine.startsWith("export ")

     

       555
       +
                       ) {

     

       556
       +
                         jsDocBlocks.set(j, jsDocContent);

     

       557
       +
                         // Mark next 5 lines as having this JSDoc (for multi-line declarations)

     

       558
       +
                         for (let k = j + 1; k <= j + 5 && k < lines.length; k++) {

     

       559
       +
                           jsDocBlocks.set(k, jsDocContent);

     

       560
       +
                         }

     

       561
       +
                       }

     

       562
       +
                       break;

     

       563
       +
                     }

     

       564
       +
                   }

     

       565
       +
                   currentJSDoc = [];

     

       566
       +
                 }

     

       567
       +
               }

     

       568
       +
       

     

       569
       +
               // Check if this line starts an export declaration

     

       570
       +
               if (isDirectExport(trimmed)) {

     

       571
       +
                 // For multi-line declarations, we need to extract the full declaration

     

       572
       +
                 let fullDeclaration = trimmed;

     

       573
       +
                 const declarationStartLine = i;

     

       574
       +
       

     

       575
       +
                 // If the line doesn't contain a complete function/class signature, gather more lines

     

       576
       +
                 if (!trimmed.includes("{") && !trimmed.includes(";")) {

     

       577
       +
                   for (let j = i + 1; j < lines.length && j < i + 10; j++) {

     

       578
       +
                     fullDeclaration += " " + lines[j].trim();

     

       579
       +
                     if (lines[j].includes("{") || lines[j].includes(";")) {

     

       580
       +
                       break;

     

       581
       +
                     }

     

       582
       +
                   }

     

       583
       +
                 }

     

       584
       +
       

     

       585
       +
                 const lineExportName = extractExportName(fullDeclaration);

     

       586
       +
                 if (lineExportName) {

     

       587
       +
                   // Find if we're tracking this specific export

     

       588
       +
                   for (const exp of sourceExports) {

     

       589
       +
                     if (

     

       590
       +
                       exp.originalName === lineExportName &&

     

       591
       +
                       exp.sourcePath === sourcePath

     

       592
       +
                     ) {

     

       593
       +
                       const symbol = parseExportedSymbol(

     

       594
       +
                         fullDeclaration,

     

       595
       +
                         declarationStartLine,

     

       596
       +
                         relativePath,

     

       597
       +
                         jsDocBlocks,

     

       598
       +
                       );

     

       599
       +
                       if (symbol) {

     

       600
       +
                         // Use the exported name from our trace

     

       601
       +
                         symbol.name = exp.exportedName;

     

       602
       +
                         symbols.push(symbol);

     

       603
       +
                       }

     

       604
       +
                       break;

     

       605
       +
                     }

     

       606
       +
                   }

     

       607
       +
                 }

     

       608
       +
               }

     

       609
       +
             }

     

       610
       +
           } catch {

     

       611
       +
             // Silently ignore errors

     

       612
       +
           }

     

       613
       +
         }

     

       614
       +
       }

     

       615
       +
       

     

       616
       +
       async function analyzeAllFiles(

     

       617
       +
         rootPath: string,

     

       618
       +
         symbols: ExportedSymbol[],

     

       619
       +
       ): Promise<void> {

     

       620
       +
         const files = await findSourceFiles(rootPath);

     

       621
       +
       

     

       622
       +
         for (const file of files) {

     

       623
       +
           await analyzeFile(file, symbols, rootPath);

     

       624
       +
         }

     

       625
       +
       }

     

       626
       +
       

     

       627
       +
       async function findSourceFiles(rootPath: string): Promise<string[]> {

     

       628
       +
         const files: string[] = [];

     

       629
       +
       

     

       630
       +
         // Check if the path is a file or directory

     

       631
       +
         const stat = await Deno.stat(rootPath);

     

       632
       +
       

     

       633
       +
         if (stat.isFile) {

     

       634
       +
           // If it's a single file, check if it's a source file

     

       635
       +
           const validExts = [".ts", ".tsx", ".js", ".jsx", ".mjs"];

     

       636
       +
           if (validExts.some((ext) => rootPath.endsWith(ext))) {

     

       637
       +
             files.push(rootPath);

     

       638
       +
           }

     

       639
       +
         } else if (stat.isDirectory) {

     

       640
       +
           // If it's a directory, walk through it

     

       641
       +
           const entries = walk(rootPath, {

     

       642
       +
             exts: [".ts", ".tsx", ".js", ".jsx", ".mjs"],

     

       643
       +
             skip: [

     

       644
       +
               /node_modules/,

     

       645
       +
               /\.git/,

     

       646
       +
               /dist/,

     

       647
       +
               /build/,

     

       648
       +
               /coverage/,

     

       649
       +
               /\.test\./,

     

       650
       +
               /\.spec\./,

     

       651
       +
               /test\//,

     

       652
       +
               /tests\//,

     

       653
       +
               /_test\./,

     

       654
       +
             ],

     

       655
       +
           });

     

       656
       +
       

     

       657
       +
           for await (const entry of entries) {

     

       658
       +
             if (entry.isFile) {

     

       659
       +
               files.push(entry.path);

     

       660
       +
             }

     

       661
       +
           }

     

       662
       +
         }

     

       663
       +
       

     

       664
       +
         return files;

     

       665
       +
       }

     

       666
       +
       

     

       667
       +
       async function analyzeFile(

     

       668
       +
         filePath: string,

     

       669
       +
         symbols: ExportedSymbol[],

     

       670
       +
         rootPath: string,

     

       671
       +
       ): Promise<void> {

     

       672
       +
         const content = await Deno.readTextFile(filePath);

     

       673
       +
         const lines = content.split("\n");

     

       674
       +
       

     

       675
       +
         // Handle both file and directory paths

     

       676
       +
         const stat = await Deno.stat(rootPath);

     

       677
       +
         const relativePath = stat.isFile

     

       678
       +
           ? relative(Deno.cwd(), filePath)

     

       679
       +
           : relative(rootPath, filePath);

     

       680
       +
       

     

       681
       +
         // Track JSDoc blocks

     

       682
       +
         const jsDocBlocks: Map<number, string> = new Map();

     

       683
       +
         let currentJSDoc: string[] = [];

     

       684
       +
       

     

       685
       +
         for (let i = 0; i < lines.length; i++) {

     

       686
       +
           const line = lines[i];

     

       687
       +
           const trimmed = line.trim();

     

       688
       +
       

     

       689
       +
           // Track JSDoc blocks

     

       690
       +
           if (trimmed.startsWith("/**")) {

     

       691
       +
             currentJSDoc = [trimmed];

     

       692
       +
           } else if (currentJSDoc.length > 0) {

     

       693
       +
             currentJSDoc.push(line);

     

       694
       +
             if (trimmed.endsWith("*/")) {

     

       695
       +
               // JSDoc block complete, associate with next code line

     

       696
       +
               const jsDocContent = currentJSDoc.join("\n");

     

       697
       +
               for (let j = i + 1; j < lines.length; j++) {

     

       698
       +
                 if (lines[j].trim() && !lines[j].trim().startsWith("//")) {

     

       699
       +
                   jsDocBlocks.set(j, jsDocContent);

     

       700
       +
                   break;

     

       701
       +
                 }

     

       702
       +
               }

     

       703
       +
               currentJSDoc = [];

     

       704
       +
             }

     

       705
       +
           }

     

       706
       +
       

     

       707
       +
           // Check for exports

     

       708
       +
           if (isExportLine(trimmed)) {

     

       709
       +
             const symbol = parseExportedSymbol(

     

       710
       +
               trimmed,

     

       711
       +
               i,

     

       712
       +
               relativePath,

     

       713
       +
               jsDocBlocks,

     

       714
       +
             );

     

       715
       +
             if (symbol) {

     

       716
       +
               symbols.push(symbol);

     

       717
       +
             }

     

       718
       +
           }

     

       719
       +
         }

     

       720
       +
       }

     

       721
       +
       

     

       722
       +
       function isExportLine(line: string): boolean {

     

       723
       +
         return (

     

       724
       +
           line.startsWith("export ") ||

     

       725
       +
           (line.includes("export {") && !line.includes("export type {")) ||

     

       726
       +
           line.includes("export default")

     

       727
       +
         );

     

       728
       +
       }

     

       729
       +
       

     

       730
       +
       function parseExportedSymbol(

     

       731
       +
         line: string,

     

       732
       +
         lineIndex: number,

     

       733
       +
         filePath: string,

     

       734
       +
         jsDocBlocks: Map<number, string>,

     

       735
       +
       ): ExportedSymbol | null {

     

       736
       +
         const trimmed = line.trim();

     

       737
       +
         let name = "";

     

       738
       +
         let type: ExportedSymbol["type"] = "variable";

     

       739
       +
         let exportType: "named" | "default" = "named";

     

       740
       +
       

     

       741
       +
         // Check for JSDoc

     

       742
       +
         const hasJSDoc = jsDocBlocks.has(lineIndex);

     

       743
       +
         const jsDocContent = jsDocBlocks.get(lineIndex);

     

       744
       +
       

     

       745
       +
         // Parse export default

     

       746
       +
         if (trimmed.includes("export default")) {

     

       747
       +
           exportType = "default";

     

       748
       +
       

     

       749
       +
           if (trimmed.includes("function")) {

     

       750
       +
             const match = trimmed.match(/function\s+(\w+)/);

     

       751
       +
             name = match ? match[1] : "default";

     

       752
       +
             type = "function";

     

       753
       +
           } else if (trimmed.includes("class")) {

     

       754
       +
             const match = trimmed.match(/class\s+(\w+)/);

     

       755
       +
             name = match ? match[1] : "default";

     

       756
       +
             type = "class";

     

       757
       +
           } else {

     

       758
       +
             name = "default";

     

       759
       +
             type = "variable";

     

       760
       +
           }

     

       761
       +
         } // Parse export function

     

       762
       +
         else if (

     

       763
       +
           trimmed.startsWith("export function") ||

     

       764
       +
           trimmed.startsWith("export async function")

     

       765
       +
         ) {

     

       766
       +
           const match = trimmed.match(/function\s+(\w+)/);

     

       767
       +
           if (match) {

     

       768
       +
             name = match[1];

     

       769
       +
             type = "function";

     

       770
       +
           }

     

       771
       +
         } // Parse export class

     

       772
       +
         else if (trimmed.startsWith("export class")) {

     

       773
       +
           const match = trimmed.match(/class\s+(\w+)/);

     

       774
       +
           if (match) {

     

       775
       +
             name = match[1];

     

       776
       +
             type = "class";

     

       777
       +
           }

     

       778
       +
         } // Parse export interface

     

       779
       +
         else if (trimmed.startsWith("export interface")) {

     

       780
       +
           const match = trimmed.match(/interface\s+(\w+)/);

     

       781
       +
           if (match) {

     

       782
       +
             name = match[1];

     

       783
       +
             type = "interface";

     

       784
       +
           }

     

       785
       +
         } // Parse export type

     

       786
       +
         else if (trimmed.startsWith("export type")) {

     

       787
       +
           const match = trimmed.match(/type\s+(\w+)/);

     

       788
       +
           if (match) {

     

       789
       +
             name = match[1];

     

       790
       +
             type = "type";

     

       791
       +
           }

     

       792
       +
         } // Parse export enum

     

       793
       +
         else if (trimmed.startsWith("export enum")) {

     

       794
       +
           const match = trimmed.match(/enum\s+(\w+)/);

     

       795
       +
           if (match) {

     

       796
       +
             name = match[1];

     

       797
       +
             type = "enum";

     

       798
       +
           }

     

       799
       +
         } // Parse export const/let/var

     

       800
       +
         else if (

     

       801
       +
           trimmed.startsWith("export const") ||

     

       802
       +
           trimmed.startsWith("export let") ||

     

       803
       +
           trimmed.startsWith("export var")

     

       804
       +
         ) {

     

       805
       +
           const match = trimmed.match(/(?:const|let|var)\s+(\w+)/);

     

       806
       +
           if (match) {

     

       807
       +
             name = match[1];

     

       808
       +
             type = trimmed.includes("const") ? "const" : "variable";

     

       809
       +
           }

     

       810
       +
         } // Parse export { ... }

     

       811
       +
         else if (trimmed.includes("export {") && !trimmed.includes("from")) {

     

       812
       +
           // Only handle direct export { ... } without from clause in this function

     

       813
       +
           // Re-exports are handled elsewhere

     

       814
       +
           const match = trimmed.match(/export\s*{\s*([^}]+)\s*}/);

     

       815
       +
           if (match) {

     

       816
       +
             const exports = match[1].split(",").map((e) => e.trim());

     

       817
       +
             // For simplicity, we'll just track the first one

     

       818
       +
             // In a real implementation, you'd want to handle all of them

     

       819
       +
             if (exports.length > 0) {

     

       820
       +
               name = exports[0].split(/\s+as\s+/)[0];

     

       821
       +
               type = "variable"; // We'd need more context to determine the actual type

     

       822
       +
             }

     

       823
       +
           }

     

       824
       +
         }

     

       825
       +
       

     

       826
       +
         if (name) {

     

       827
       +
           return {

     

       828
       +
             name,

     

       829
       +
             type,

     

       830
       +
             file: filePath,

     

       831
       +
             line: lineIndex + 1,

     

       832
       +
             hasJSDoc,

     

       833
       +
             jsDocContent,

     

       834
       +
             exportType,

     

       835
       +
           };

     

       836
       +
         }

     

       837
       +
       

     

       838
       +
         return null;

     

       839
       +
       }

     

       840
       +
       

     

       841
       +
       export function calculateStats(symbols: ExportedSymbol[]): DocumentationStats {

     

       842
       +
         const stats: DocumentationStats = {

     

       843
       +
           total: symbols.length,

     

       844
       +
           documented: symbols.filter((s) => s.hasJSDoc).length,

     

       845
       +
           undocumented: symbols.filter((s) => !s.hasJSDoc).length,

     

       846
       +
           percentage: 0,

     

       847
       +
           byType: {},

     

       848
       +
         };

     

       849
       +
       

     

       850
       +
         stats.percentage = stats.total > 0

     

       851
       +
           ? Math.round((stats.documented / stats.total) * 100)

     

       852
       +
           : 100;

     

       853
       +
       

     

       854
       +
         // Calculate stats by type

     

       855
       +
         for (const symbol of symbols) {

     

       856
       +
           if (!stats.byType[symbol.type]) {

     

       857
       +
             stats.byType[symbol.type] = { total: 0, documented: 0 };

     

       858
       +
           }

     

       859
       +
           stats.byType[symbol.type].total++;

     

       860
       +
           if (symbol.hasJSDoc) {

     

       861
       +
             stats.byType[symbol.type].documented++;

     

       862
       +
           }

     

       863
       +
         }

     

       864
       +
       

     

       865
       +
         return stats;

     

       866
       +
       }

+11

deno.json

···

       1
       +
       {

     

       2
       +
         "name": "@knotbin/doggo",

     

       3
       +
         "version": "0.1.0",

     

       4
       +
         "exports": "./mod.ts",

     

       5
       +
         "imports": {

     

       6
       +
           "@std/cli": "jsr:@std/cli@^1.0.23",

     

       7
       +
           "@std/fmt": "jsr:@std/fmt@^1.0.8",

     

       8
       +
           "@std/fs": "jsr:@std/fs@^1.0.19",

     

       9
       +
           "@std/path": "jsr:@std/path@^1.1.2"

     

       10
       +
         }

     

       11
       +
       }

+146

deno.lock

···

       1
       +
       {

     

       2
       +
         "version": "5",

     

       3
       +
         "specifiers": {

     

       4
       +
           "jsr:@std/cli@^1.0.23": "1.0.23",

     

       5
       +
           "jsr:@std/fmt@^1.0.8": "1.0.8",

     

       6
       +
           "jsr:@std/fs@^1.0.19": "1.0.19",

     

       7
       +
           "jsr:@std/internal@^1.0.10": "1.0.12",

     

       8
       +
           "jsr:@std/internal@^1.0.12": "1.0.12",

     

       9
       +
           "jsr:@std/internal@^1.0.9": "1.0.12",

     

       10
       +
           "jsr:@std/path@^1.1.1": "1.1.2",

     

       11
       +
           "jsr:@std/path@^1.1.2": "1.1.2",

     

       12
       +
           "npm:@types/node@*": "24.2.0"

     

       13
       +
         },

     

       14
       +
         "jsr": {

     

       15
       +
           "@std/cli@1.0.23": {

     

       16
       +
             "integrity": "bf95b7a9425ba2af1ae5a6359daf58c508f2decf711a76ed2993cd352498ccca",

     

       17
       +
             "dependencies": [

     

       18
       +
               "jsr:@std/internal@^1.0.12"

     

       19
       +
             ]

     

       20
       +
           },

     

       21
       +
           "@std/fmt@1.0.8": {

     

       22
       +
             "integrity": "71e1fc498787e4434d213647a6e43e794af4fd393ef8f52062246e06f7e372b7"

     

       23
       +
           },

     

       24
       +
           "@std/fs@1.0.19": {

     

       25
       +
             "integrity": "051968c2b1eae4d2ea9f79a08a3845740ef6af10356aff43d3e2ef11ed09fb06",

     

       26
       +
             "dependencies": [

     

       27
       +
               "jsr:@std/internal@^1.0.9",

     

       28
       +
               "jsr:@std/path@^1.1.1"

     

       29
       +
             ]

     

       30
       +
           },

     

       31
       +
           "@std/internal@1.0.12": {

     

       32
       +
             "integrity": "972a634fd5bc34b242024402972cd5143eac68d8dffaca5eaa4dba30ce17b027"

     

       33
       +
           },

     

       34
       +
           "@std/path@1.1.2": {

     

       35
       +
             "integrity": "c0b13b97dfe06546d5e16bf3966b1cadf92e1cc83e56ba5476ad8b498d9e3038",

     

       36
       +
             "dependencies": [

     

       37
       +
               "jsr:@std/internal@^1.0.10"

     

       38
       +
             ]

     

       39
       +
           }

     

       40
       +
         },

     

       41
       +
         "npm": {

     

       42
       +
           "@types/node@24.2.0": {

     

       43
       +
             "integrity": "sha512-3xyG3pMCq3oYCNg7/ZP+E1ooTaGB4cG8JWRsqqOYQdbWNY4zbaV0Ennrd7stjiJEFZCaybcIgpTjJWHRfBSIDw==",

     

       44
       +
             "dependencies": [

     

       45
       +
               "undici-types"

     

       46
       +
             ]

     

       47
       +
           },

     

       48
       +
           "undici-types@7.10.0": {

     

       49
       +
             "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="

     

       50
       +
           }

     

       51
       +
         },

     

       52
       +
         "remote": {

     

       53
       +
           "https://deno.land/std@0.208.0/assert/assert.ts": "9a97dad6d98c238938e7540736b826440ad8c1c1e54430ca4c4e623e585607ee",

     

       54
       +
           "https://deno.land/std@0.208.0/assert/assertion_error.ts": "4d0bde9b374dfbcbe8ac23f54f567b77024fb67dbb1906a852d67fe050d42f56",

     

       55
       +
           "https://deno.land/std@0.208.0/cli/parse_args.ts": "9bea02050b3f302e706871ff87ecfa3ad82cc34249adbe0dcddfaac75bdb48ff",

     

       56
       +
           "https://deno.land/std@0.208.0/flags/mod.ts": "567a34800a33e701942cb1726dd7e627a76e4681c33ce7346ac85cf90f691a8e",

     

       57
       +
           "https://deno.land/std@0.208.0/fmt/colors.ts": "34b3f77432925eb72cf0bfb351616949746768620b8e5ead66da532f93d10ba2",

     

       58
       +
           "https://deno.land/std@0.208.0/fs/_util.ts": "fbf57dcdc9f7bc8128d60301eece608246971a7836a3bb1e78da75314f08b978",

     

       59
       +
           "https://deno.land/std@0.208.0/fs/walk.ts": "c1e6b43f72a46e89b630140308bd51a4795d416a416b4cfb7cd4bd1e25946723",

     

       60
       +
           "https://deno.land/std@0.208.0/path/_common/assert_path.ts": "061e4d093d4ba5aebceb2c4da3318bfe3289e868570e9d3a8e327d91c2958946",

     

       61
       +
           "https://deno.land/std@0.208.0/path/_common/basename.ts": "0d978ff818f339cd3b1d09dc914881f4d15617432ae519c1b8fdc09ff8d3789a",

     

       62
       +
           "https://deno.land/std@0.208.0/path/_common/common.ts": "9e4233b2eeb50f8b2ae10ecc2108f58583aea6fd3e8907827020282dc2b76143",

     

       63
       +
           "https://deno.land/std@0.208.0/path/_common/constants.ts": "e49961f6f4f48039c0dfed3c3f93e963ca3d92791c9d478ac5b43183413136e0",

     

       64
       +
           "https://deno.land/std@0.208.0/path/_common/dirname.ts": "2ba7fb4cc9fafb0f38028f434179579ce61d4d9e51296fad22b701c3d3cd7397",

     

       65
       +
           "https://deno.land/std@0.208.0/path/_common/format.ts": "11aa62e316dfbf22c126917f5e03ea5fe2ee707386555a8f513d27ad5756cf96",

     

       66
       +
           "https://deno.land/std@0.208.0/path/_common/from_file_url.ts": "ef1bf3197d2efbf0297a2bdbf3a61d804b18f2bcce45548ae112313ec5be3c22",

     

       67
       +
           "https://deno.land/std@0.208.0/path/_common/glob_to_reg_exp.ts": "5c3c2b79fc2294ec803d102bd9855c451c150021f452046312819fbb6d4dc156",

     

       68
       +
           "https://deno.land/std@0.208.0/path/_common/normalize.ts": "2ba7fb4cc9fafb0f38028f434179579ce61d4d9e51296fad22b701c3d3cd7397",

     

       69
       +
           "https://deno.land/std@0.208.0/path/_common/normalize_string.ts": "88c472f28ae49525f9fe82de8c8816d93442d46a30d6bb5063b07ff8a89ff589",

     

       70
       +
           "https://deno.land/std@0.208.0/path/_common/relative.ts": "1af19d787a2a84b8c534cc487424fe101f614982ae4851382c978ab2216186b4",

     

       71
       +
           "https://deno.land/std@0.208.0/path/_common/strip_trailing_separators.ts": "7ffc7c287e97bdeeee31b155828686967f222cd73f9e5780bfe7dfb1b58c6c65",

     

       72
       +
           "https://deno.land/std@0.208.0/path/_common/to_file_url.ts": "a8cdd1633bc9175b7eebd3613266d7c0b6ae0fb0cff24120b6092ac31662f9ae",

     

       73
       +
           "https://deno.land/std@0.208.0/path/_interface.ts": "6471159dfbbc357e03882c2266d21ef9afdb1e4aa771b0545e90db58a0ba314b",

     

       74
       +
           "https://deno.land/std@0.208.0/path/_os.ts": "30b0c2875f360c9296dbe6b7f2d528f0f9c741cecad2e97f803f5219e91b40a2",

     

       75
       +
           "https://deno.land/std@0.208.0/path/basename.ts": "04bb5ef3e86bba8a35603b8f3b69537112cdd19ce64b77f2522006da2977a5f3",

     

       76
       +
           "https://deno.land/std@0.208.0/path/common.ts": "f4d061c7d0b95a65c2a1a52439edec393e906b40f1caf4604c389fae7caa80f5",

     

       77
       +
           "https://deno.land/std@0.208.0/path/dirname.ts": "88a0a71c21debafc4da7a4cd44fd32e899462df458fbca152390887d41c40361",

     

       78
       +
           "https://deno.land/std@0.208.0/path/extname.ts": "2da4e2490f3b48b7121d19fb4c91681a5e11bd6bd99df4f6f47d7a71bb6ecdf2",

     

       79
       +
           "https://deno.land/std@0.208.0/path/format.ts": "3457530cc85d1b4bab175f9ae73998b34fd456c830d01883169af0681b8894fb",

     

       80
       +
           "https://deno.land/std@0.208.0/path/from_file_url.ts": "e7fa233ea1dff9641e8d566153a24d95010110185a6f418dd2e32320926043f8",

     

       81
       +
           "https://deno.land/std@0.208.0/path/glob_to_regexp.ts": "74d7448c471e293d03f05ccb968df4365fed6aaa508506b6325a8efdc01d8271",

     

       82
       +
           "https://deno.land/std@0.208.0/path/is_absolute.ts": "67232b41b860571c5b7537f4954c88d86ae2ba45e883ee37d3dec27b74909d13",

     

       83
       +
           "https://deno.land/std@0.208.0/path/is_glob.ts": "567dce5c6656bdedfc6b3ee6c0833e1e4db2b8dff6e62148e94a917f289c06ad",

     

       84
       +
           "https://deno.land/std@0.208.0/path/join.ts": "98d3d76c819af4a11a81d5ba2dbb319f1ce9d63fc2b615597d4bcfddd4a89a09",

     

       85
       +
           "https://deno.land/std@0.208.0/path/join_globs.ts": "9b84d5103b63d3dbed4b2cf8b12477b2ad415c7d343f1488505162dc0e5f4db8",

     

       86
       +
           "https://deno.land/std@0.208.0/path/mod.ts": "3defabebc98279e62b392fee7a6937adc932a8f4dcd2471441e36c15b97b00e0",

     

       87
       +
           "https://deno.land/std@0.208.0/path/normalize.ts": "aa95be9a92c7bd4f9dc0ba51e942a1973e2b93d266cd74f5ca751c136d520b66",

     

       88
       +
           "https://deno.land/std@0.208.0/path/normalize_glob.ts": "674baa82e1c00b6cb153bbca36e06f8e0337cb8062db6d905ab5de16076ca46b",

     

       89
       +
           "https://deno.land/std@0.208.0/path/parse.ts": "d87ff0deef3fb495bc0d862278ff96da5a06acf0625ca27769fc52ac0d3d6ece",

     

       90
       +
           "https://deno.land/std@0.208.0/path/posix/_util.ts": "ecf49560fedd7dd376c6156cc5565cad97c1abe9824f4417adebc7acc36c93e5",

     

       91
       +
           "https://deno.land/std@0.208.0/path/posix/basename.ts": "a630aeb8fd8e27356b1823b9dedd505e30085015407caa3396332752f6b8406a",

     

       92
       +
           "https://deno.land/std@0.208.0/path/posix/common.ts": "e781d395dc76f6282e3f7dd8de13194abb8b04a82d109593141abc6e95755c8b",

     

       93
       +
           "https://deno.land/std@0.208.0/path/posix/dirname.ts": "f48c9c42cc670803b505478b7ef162c7cfa9d8e751b59d278b2ec59470531472",

     

       94
       +
           "https://deno.land/std@0.208.0/path/posix/extname.ts": "ee7f6571a9c0a37f9218fbf510c440d1685a7c13082c348d701396cc795e0be0",

     

       95
       +
           "https://deno.land/std@0.208.0/path/posix/format.ts": "b94876f77e61bfe1f147d5ccb46a920636cd3cef8be43df330f0052b03875968",

     

       96
       +
           "https://deno.land/std@0.208.0/path/posix/from_file_url.ts": "b97287a83e6407ac27bdf3ab621db3fccbf1c27df0a1b1f20e1e1b5acf38a379",

     

       97
       +
           "https://deno.land/std@0.208.0/path/posix/glob_to_regexp.ts": "6ed00c71fbfe0ccc35977c35444f94e82200b721905a60bd1278b1b768d68b1a",

     

       98
       +
           "https://deno.land/std@0.208.0/path/posix/is_absolute.ts": "159900a3422d11069d48395568217eb7fc105ceda2683d03d9b7c0f0769e01b8",

     

       99
       +
           "https://deno.land/std@0.208.0/path/posix/is_glob.ts": "ec4fbc604b9db8487f7b56ab0e759b24a971ab6a45f7b0b698bc39b8b9f9680f",

     

       100
       +
           "https://deno.land/std@0.208.0/path/posix/join.ts": "0c0d84bdc344876930126640011ec1b888e6facf74153ffad9ef26813aa2a076",

     

       101
       +
           "https://deno.land/std@0.208.0/path/posix/join_globs.ts": "f4838d54b1f60a34a40625a3293f6e583135348be1b2974341ac04743cb26121",

     

       102
       +
           "https://deno.land/std@0.208.0/path/posix/mod.ts": "f1b08a7f64294b7de87fc37190d63b6ce5b02889af9290c9703afe01951360ae",

     

       103
       +
           "https://deno.land/std@0.208.0/path/posix/normalize.ts": "11de90a94ab7148cc46e5a288f7d732aade1d616bc8c862f5560fa18ff987b4b",

     

       104
       +
           "https://deno.land/std@0.208.0/path/posix/normalize_glob.ts": "10a1840c628ebbab679254d5fa1c20e59106102354fb648a1765aed72eb9f3f9",

     

       105
       +
           "https://deno.land/std@0.208.0/path/posix/parse.ts": "199208f373dd93a792e9c585352bfc73a6293411bed6da6d3bc4f4ef90b04c8e",

     

       106
       +
           "https://deno.land/std@0.208.0/path/posix/relative.ts": "e2f230608b0f083e6deaa06e063943e5accb3320c28aef8d87528fbb7fe6504c",

     

       107
       +
           "https://deno.land/std@0.208.0/path/posix/resolve.ts": "51579d83159d5c719518c9ae50812a63959bbcb7561d79acbdb2c3682236e285",

     

       108
       +
           "https://deno.land/std@0.208.0/path/posix/separator.ts": "0b6573b5f3269a3164d8edc9cefc33a02dd51003731c561008c8bb60220ebac1",

     

       109
       +
           "https://deno.land/std@0.208.0/path/posix/to_file_url.ts": "08d43ea839ee75e9b8b1538376cfe95911070a655cd312bc9a00f88ef14967b6",

     

       110
       +
           "https://deno.land/std@0.208.0/path/posix/to_namespaced_path.ts": "c9228a0e74fd37e76622cd7b142b8416663a9b87db643302fa0926b5a5c83bdc",

     

       111
       +
           "https://deno.land/std@0.208.0/path/relative.ts": "23d45ede8b7ac464a8299663a43488aad6b561414e7cbbe4790775590db6349c",

     

       112
       +
           "https://deno.land/std@0.208.0/path/resolve.ts": "5b184efc87155a0af9fa305ff68a109e28de9aee81fc3e77cd01380f19daf867",

     

       113
       +
           "https://deno.land/std@0.208.0/path/separator.ts": "40a3e9a4ad10bef23bc2cd6c610291b6c502a06237c2c4cd034a15ca78dedc1f",

     

       114
       +
           "https://deno.land/std@0.208.0/path/to_file_url.ts": "edaafa089e0bce386e1b2d47afe7c72e379ff93b28a5829a5885e4b6c626d864",

     

       115
       +
           "https://deno.land/std@0.208.0/path/to_namespaced_path.ts": "cf8734848aac3c7527d1689d2adf82132b1618eff3cc523a775068847416b22a",

     

       116
       +
           "https://deno.land/std@0.208.0/path/windows/_util.ts": "f32b9444554c8863b9b4814025c700492a2b57ff2369d015360970a1b1099d54",

     

       117
       +
           "https://deno.land/std@0.208.0/path/windows/basename.ts": "8a9dbf7353d50afbc5b221af36c02a72c2d1b2b5b9f7c65bf6a5a2a0baf88ad3",

     

       118
       +
           "https://deno.land/std@0.208.0/path/windows/common.ts": "e781d395dc76f6282e3f7dd8de13194abb8b04a82d109593141abc6e95755c8b",

     

       119
       +
           "https://deno.land/std@0.208.0/path/windows/dirname.ts": "5c2aa541384bf0bd9aca821275d2a8690e8238fa846198ef5c7515ce31a01a94",

     

       120
       +
           "https://deno.land/std@0.208.0/path/windows/extname.ts": "07f4fa1b40d06a827446b3e3bcc8d619c5546b079b8ed0c77040bbef716c7614",

     

       121
       +
           "https://deno.land/std@0.208.0/path/windows/format.ts": "343019130d78f172a5c49fdc7e64686a7faf41553268961e7b6c92a6d6548edf",

     

       122
       +
           "https://deno.land/std@0.208.0/path/windows/from_file_url.ts": "d53335c12b0725893d768be3ac6bf0112cc5b639d2deb0171b35988493b46199",

     

       123
       +
           "https://deno.land/std@0.208.0/path/windows/glob_to_regexp.ts": "290755e18ec6c1a4f4d711c3390537358e8e3179581e66261a0cf348b1a13395",

     

       124
       +
           "https://deno.land/std@0.208.0/path/windows/is_absolute.ts": "245b56b5f355ede8664bd7f080c910a97e2169972d23075554ae14d73722c53c",

     

       125
       +
           "https://deno.land/std@0.208.0/path/windows/is_glob.ts": "ec4fbc604b9db8487f7b56ab0e759b24a971ab6a45f7b0b698bc39b8b9f9680f",

     

       126
       +
           "https://deno.land/std@0.208.0/path/windows/join.ts": "e6600bf88edeeef4e2276e155b8de1d5dec0435fd526ba2dc4d37986b2882f16",

     

       127
       +
           "https://deno.land/std@0.208.0/path/windows/join_globs.ts": "f4838d54b1f60a34a40625a3293f6e583135348be1b2974341ac04743cb26121",

     

       128
       +
           "https://deno.land/std@0.208.0/path/windows/mod.ts": "d7040f461465c2c21c1c68fc988ef0bdddd499912138cde3abf6ad60c7fb3814",

     

       129
       +
           "https://deno.land/std@0.208.0/path/windows/normalize.ts": "9deebbf40c81ef540b7b945d4ccd7a6a2c5a5992f791e6d3377043031e164e69",

     

       130
       +
           "https://deno.land/std@0.208.0/path/windows/normalize_glob.ts": "344ff5ed45430495b9a3d695567291e50e00b1b3b04ea56712a2acf07ab5c128",

     

       131
       +
           "https://deno.land/std@0.208.0/path/windows/parse.ts": "120faf778fe1f22056f33ded069b68e12447668fcfa19540c0129561428d3ae5",

     

       132
       +
           "https://deno.land/std@0.208.0/path/windows/relative.ts": "026855cd2c36c8f28f1df3c6fbd8f2449a2aa21f48797a74700c5d872b86d649",

     

       133
       +
           "https://deno.land/std@0.208.0/path/windows/resolve.ts": "5ff441ab18a2346abadf778121128ee71bda4d0898513d4639a6ca04edca366b",

     

       134
       +
           "https://deno.land/std@0.208.0/path/windows/separator.ts": "ae21f27015f10510ed1ac4a0ba9c4c9c967cbdd9d9e776a3e4967553c397bd5d",

     

       135
       +
           "https://deno.land/std@0.208.0/path/windows/to_file_url.ts": "8e9ea9e1ff364aa06fa72999204229952d0a279dbb876b7b838b2b2fea55cce3",

     

       136
       +
           "https://deno.land/std@0.208.0/path/windows/to_namespaced_path.ts": "e0f4d4a5e77f28a5708c1a33ff24360f35637ba6d8f103d19661255ef7bfd50d"

     

       137
       +
         },

     

       138
       +
         "workspace": {

     

       139
       +
           "dependencies": [

     

       140
       +
             "jsr:@std/cli@^1.0.23",

     

       141
       +
             "jsr:@std/fmt@^1.0.8",

     

       142
       +
             "jsr:@std/fs@^1.0.19",

     

       143
       +
             "jsr:@std/path@^1.1.2"

     

       144
       +
           ]

     

       145
       +
         }

     

       146
       +
       }

+295

mod.ts

···

       1
       +
       /**

     

       2
       +
        * 🐶 Doggo - JSDoc Coverage Analyzer for Deno

     

       3
       +
        *

     

       4
       +
        * A loyal companion for your documentation journey! Doggo sniffs out undocumented

     

       5
       +
        * exports in your Deno packages and helps you achieve 100% JSDoc coverage.

     

       6
       +
        *

     

       7
       +
        * @module

     

       8
       +
        *

     

       9
       +
        * @example Install Doggo

     

       10
       +
        * ```bash

     

       11
       +
        * deno install --global --allow-read jsr:@knotbin/doggo --name doggo

     

       12
       +
        * ```

     

       13
       +
        *

     

       14
       +
        * @example Usage

     

       15
       +
        * ```bash

     

       16
       +
        * # Run Doggo in the current directory

     

       17
       +
        * doggo

     

       18
       +
        * # Run Doggo in a specific directory

     

       19
       +
        * doggo /path/to/directory

     

       20
       +
        * # Run Doggo for a specific file

     

       21
       +
        * doggo /path/to/file.ts

     

       22
       +
        * ```

     

       23
       +
        */

     

       24
       +
       

     

       25
       +
       import { parseArgs } from "@std/cli";

     

       26
       +
       import { join, resolve } from "@std/path";

     

       27
       +
       import { bold, cyan, gray, green, red, yellow } from "@std/fmt/colors";

     

       28
       +
       import {

     

       29
       +
         analyzeDirectory,

     

       30
       +
         type DocumentationStats,

     

       31
       +
         type ExportedSymbol,

     

       32
       +
       } from "./core.ts";

     

       33
       +
       

     

       34
       +
       class JSDocAnalyzer {

     

       35
       +
         private rootPath: string;

     

       36
       +
       

     

       37
       +
         constructor(rootPath: string) {

     

       38
       +
           this.rootPath = resolve(rootPath);

     

       39
       +
         }

     

       40
       +
       

     

       41
       +
         async analyze(): Promise<void> {

     

       42
       +
           console.log(

     

       43
       +
             cyan(bold("\n🐶 Doggo is analyzing your documentation coverage!\n")),

     

       44
       +
           );

     

       45
       +
           console.log(gray(`Path: ${this.rootPath}\n`));

     

       46
       +
       

     

       47
       +
           // Use core module for analysis

     

       48
       +
           const result = await analyzeDirectory(this.rootPath);

     

       49
       +
       

     

       50
       +
           if (result.hasDenoJson && result.hasExports) {

     

       51
       +
             console.log(gray(`Found deno.json with exports: ${result.exportPath}\n`));

     

       52
       +
             console.log(

     

       53
       +
               cyan("Sniffing out public API from export entry points...\n"),

     

       54
       +
             );

     

       55
       +
           }

     

       56
       +
       

     

       57
       +
           // Output results

     

       58
       +
           this.outputResults(result.symbols, result.stats);

     

       59
       +
         }

     

       60
       +
       

     

       61
       +
         private outputResults(

     

       62
       +
           symbols: ExportedSymbol[],

     

       63
       +
           stats: DocumentationStats,

     

       64
       +
         ): void {

     

       65
       +
           if (symbols.length === 0) {

     

       66
       +
             console.log(yellow("Woof! No exported symbols found. 🦴"));

     

       67
       +
             return;

     

       68
       +
           }

     

       69
       +
       

     

       70
       +
           // Output undocumented symbols

     

       71
       +
           const undocumented = symbols.filter((s) => !s.hasJSDoc);

     

       72
       +
       

     

       73
       +
           if (undocumented.length > 0) {

     

       74
       +
             console.log(red(bold("📝 Undocumented Exports (Doggo found these!):\n")));

     

       75
       +
       

     

       76
       +
             // Group by file

     

       77
       +
             const byFile = new Map<string, ExportedSymbol[]>();

     

       78
       +
             for (const symbol of undocumented) {

     

       79
       +
               if (!byFile.has(symbol.file)) {

     

       80
       +
                 byFile.set(symbol.file, []);

     

       81
       +
               }

     

       82
       +
               byFile.get(symbol.file)!.push(symbol);

     

       83
       +
             }

     

       84
       +
       

     

       85
       +
             // Output by file

     

       86
       +
             for (const [file, symbols] of byFile.entries()) {

     

       87
       +
               console.log(yellow(`  ${file}:`));

     

       88
       +
               for (const symbol of symbols.sort((a, b) => a.line - b.line)) {

     

       89
       +
                 const typeLabel = gray(`[${symbol.type}]`);

     

       90
       +
                 const lineNum = gray(`:${symbol.line}`);

     

       91
       +
                 console.log(`    ${red("✗")} ${symbol.name} ${typeLabel}${lineNum}`);

     

       92
       +
               }

     

       93
       +
               console.log();

     

       94
       +
             }

     

       95
       +
           } else {

     

       96
       +
             console.log(

     

       97
       +
               green(bold("✨ Good boy! All exported symbols are documented!\n")),

     

       98
       +
             );

     

       99
       +
           }

     

       100
       +
       

     

       101
       +
           // Output summary

     

       102
       +
           this.outputSummary(stats);

     

       103
       +
         }

     

       104
       +
       

     

       105
       +
         private outputSummary(stats: DocumentationStats): void {

     

       106
       +
           console.log(bold(cyan("📊 Documentation Coverage Summary\n")));

     

       107
       +
           console.log(gray("─".repeat(50)));

     

       108
       +
       

     

       109
       +
           // Overall stats

     

       110
       +
           const percentageColor = stats.percentage >= 80

     

       111
       +
             ? green

     

       112
       +
             : stats.percentage >= 60

     

       113
       +
             ? yellow

     

       114
       +
             : red;

     

       115
       +
       

     

       116
       +
           console.log(`  Total Exports:     ${bold(stats.total.toString())}`);

     

       117
       +
           console.log(`  Documented:        ${green(stats.documented.toString())}`);

     

       118
       +
           console.log(`  Undocumented:      ${red(stats.undocumented.toString())}`);

     

       119
       +
           console.log(

     

       120
       +
             `  Coverage:          ${percentageColor(bold(`${stats.percentage}%`))}`,

     

       121
       +
           );

     

       122
       +
       

     

       123
       +
           // Stats by type

     

       124
       +
           if (Object.keys(stats.byType).length > 0) {

     

       125
       +
             console.log(gray("─".repeat(50)));

     

       126
       +
             console.log(bold("\n  Coverage by Type:\n"));

     

       127
       +
       

     

       128
       +
             for (const [type, typeStats] of Object.entries(stats.byType)) {

     

       129
       +
               const percentage = typeStats.total > 0

     

       130
       +
                 ? Math.round((typeStats.documented / typeStats.total) * 100)

     

       131
       +
                 : 100;

     

       132
       +
               const percentageColor = percentage >= 80

     

       133
       +
                 ? green

     

       134
       +
                 : percentage >= 60

     

       135
       +
                 ? yellow

     

       136
       +
                 : red;

     

       137
       +
       

     

       138
       +
               const typeLabel = type.padEnd(12);

     

       139
       +
               const statsStr = `${typeStats.documented}/${typeStats.total}`.padEnd(7);

     

       140
       +
               console.log(

     

       141
       +
                 `    ${typeLabel} ${statsStr} ${percentageColor(`${percentage}%`)}`,

     

       142
       +
               );

     

       143
       +
             }

     

       144
       +
           }

     

       145
       +
       

     

       146
       +
           console.log(gray("─".repeat(50)));

     

       147
       +
       

     

       148
       +
           // Coverage indicator

     

       149
       +
           const indicator = this.getCoverageIndicator(stats.percentage);

     

       150
       +
           console.log(`\n  ${indicator}`);

     

       151
       +
         }

     

       152
       +
       

     

       153
       +
         private getCoverageIndicator(percentage: number): string {

     

       154
       +
           if (percentage === 100) {

     

       155
       +
             return green("🏆 Perfect! Doggo is doing zoomies!");

     

       156
       +
           } else if (percentage >= 90) {

     

       157
       +
             return green("✨ Excellent! Tail wagging intensifies!");

     

       158
       +
           } else if (percentage >= 80) {

     

       159
       +
             return green("👍 Good boy! Happy tail wags");

     

       160
       +
           } else if (percentage >= 60) {

     

       161
       +
             return yellow("📈 Doggo needs more treats (documentation)");

     

       162
       +
           } else if (percentage >= 40) {

     

       163
       +
             return red("⚠️  Poor coverage (Sad puppy eyes)");

     

       164
       +
           } else {

     

       165
       +
             return red("🚨 Critical! Doggo is hiding under the bed");

     

       166
       +
           }

     

       167
       +
         }

     

       168
       +
       }

     

       169
       +
       

     

       170
       +
       // Main CLI

     

       171
       +
       async function main() {

     

       172
       +
         const args = parseArgs(Deno.args, {

     

       173
       +
           string: ["path"],

     

       174
       +
           boolean: ["help", "version", "workspace"],

     

       175
       +
           alias: {

     

       176
       +
             h: "help",

     

       177
       +
             v: "version",

     

       178
       +
             p: "path",

     

       179
       +
             w: "workspace",

     

       180
       +
           },

     

       181
       +
           default: {

     

       182
       +
             path: ".",

     

       183
       +
           },

     

       184
       +
         });

     

       185
       +
       

     

       186
       +
         if (args.help) {

     

       187
       +
           console.log(`

     

       188
       +
        ${bold("🐶 Doggo - The Doc Sniffing Dog")}

     

       189
       +
       

     

       190
       +
        A loyal companion for your documentation journey! Doggo sniffs out undocumented

     

       191
       +
        exports in your Deno packages and helps you achieve 100% JSDoc coverage.

     

       192
       +
       

     

       193
       +
               __

     

       194
       +
          (___()'${"`"};

     

       195
       +
          /,___ /${"`"}

     

       196
       +
          ${"\\\\"}   ${"\\\\"}   Woof! Let's document that code!

     

       197
       +
       

     

       198
       +
        ${bold("Usage:")}

     

       199
       +
          doggo [options] [path]

     

       200
       +
       

     

       201
       +
        ${bold("Options:")}

     

       202
       +
          -h, --help      Show help (Doggo does tricks!)

     

       203
       +
          -v, --version   Show version (Doggo's age in dog years)

     

       204
       +
          -p, --path      Path to analyze (where should Doggo sniff?)

     

       205
       +
          -w, --workspace Force workspace mode (analyze the whole pack!)

     

       206
       +
       

     

       207
       +
        ${bold("Examples:")}

     

       208
       +
          doggo                           # Analyze current directory

     

       209
       +
          doggo ./src                     # Analyze specific directory

     

       210
       +
          doggo ./src/module.ts          # Analyze single file

     

       211
       +
          doggo --workspace              # Analyze all workspace members

     

       212
       +
       

     

       213
       +
        ${bold("Notes:")}

     

       214
       +
          🦴 If a workspace configuration is found, analyzes all pack members

     

       215
       +
          🎯 If a deno.json 'exports' field is found, analyzes only the public API

     

       216
       +
          🔍 Otherwise, sniffs out all exported symbols in the codebase

     

       217
       +
       

     

       218
       +
        ${bold("Remember:")} A well-documented codebase is like a well-trained dog -

     

       219
       +
        everyone loves working with it!

     

       220
       +
        `);

     

       221
       +
           Deno.exit(0);

     

       222
       +
         }

     

       223
       +
       

     

       224
       +
         if (args.version) {

     

       225
       +
           console.log("🐶 Doggo - The goodest documentation boy!");

     

       226
       +
           Deno.exit(0);

     

       227
       +
         }

     

       228
       +
       

     

       229
       +
         // Get path from positional argument or --path flag

     

       230
       +
         const targetPath = args._[0]?.toString() || args.path;

     

       231
       +
       

     

       232
       +
         try {

     

       233
       +
           // Check if we should try workspace mode

     

       234
       +
           const workspaceConfigPath = join(resolve(targetPath), "deno.json");

     

       235
       +
           const workspaceConfigPathJsonc = join(resolve(targetPath), "deno.jsonc");

     

       236
       +
       

     

       237
       +
           let hasWorkspace = false;

     

       238
       +
       

     

       239
       +
           // Check for workspace configuration

     

       240
       +
           try {

     

       241
       +
             const content = await Deno.readTextFile(workspaceConfigPath);

     

       242
       +
             const config = JSON.parse(content);

     

       243
       +
             hasWorkspace = !!config.workspace;

     

       244
       +
           } catch {

     

       245
       +
             // Try deno.jsonc

     

       246
       +
             try {

     

       247
       +
               const content = await Deno.readTextFile(workspaceConfigPathJsonc);

     

       248
       +
               // Simple JSONC parsing

     

       249
       +
               const jsonContent = content

     

       250
       +
                 .split("\n")

     

       251
       +
                 .map((line) => {

     

       252
       +
                   const commentIndex = line.indexOf("//");

     

       253
       +
                   return commentIndex > -1 ? line.slice(0, commentIndex) : line;

     

       254
       +
                 })

     

       255
       +
                 .join("\n")

     

       256
       +
                 .replace(/\/\*[\s\S]*?\*\//g, "");

     

       257
       +
               const config = JSON.parse(jsonContent);

     

       258
       +
               hasWorkspace = !!config.workspace;

     

       259
       +
             } catch {

     

       260
       +
               // No workspace config found

     

       261
       +
             }

     

       262
       +
           }

     

       263
       +
       

     

       264
       +
           // Use workspace analyzer if workspace found or forced

     

       265
       +
           if (hasWorkspace || args.workspace) {

     

       266
       +
             const { WorkspaceAnalyzer } = await import("./workspace.ts");

     

       267
       +
             const workspaceAnalyzer = new WorkspaceAnalyzer(targetPath);

     

       268
       +
             const report = await workspaceAnalyzer.analyze();

     

       269
       +
       

     

       270
       +
             if (!report && args.workspace) {

     

       271
       +
               console.log(yellow("\n⚠️  Woof! No workspace configuration found."));

     

       272
       +
               console.log(

     

       273
       +
                 gray(

     

       274
       +
                   "Doggo was looking for 'workspace' field in deno.json or deno.jsonc\n",

     

       275
       +
                 ),

     

       276
       +
               );

     

       277
       +
               Deno.exit(1);

     

       278
       +
             }

     

       279
       +
           } else {

     

       280
       +
             // Regular single-package analysis

     

       281
       +
             const analyzer = new JSDocAnalyzer(targetPath);

     

       282
       +
             await analyzer.analyze();

     

       283
       +
           }

     

       284
       +
         } catch (error) {

     

       285
       +
           console.error(red(`Error: ${error}`));

     

       286
       +
           Deno.exit(1);

     

       287
       +
         }

     

       288
       +
       }

     

       289
       +
       

     

       290
       +
       // Export for use in workspace.ts

     

       291
       +
       export { JSDocAnalyzer };

     

       292
       +
       

     

       293
       +
       if (import.meta.main) {

     

       294
       +
         await main();

     

       295
       +
       }

+377

workspace.ts

···

       1
       +
       import { bold, cyan, gray, green, red, yellow } from "@std/fmt/colors";

     

       2
       +
       import { join, resolve } from "@std/path";

     

       3
       +
       import { analyzeDirectory } from "./core.ts";

     

       4
       +
       

     

       5
       +
       interface WorkspaceConfig {

     

       6
       +
         workspace?: string[];

     

       7
       +
         imports?: Record<string, string>;

     

       8
       +
       }

     

       9
       +
       

     

       10
       +
       interface WorkspaceMemberStats {

     

       11
       +
         name: string;

     

       12
       +
         path: string;

     

       13
       +
         hasDenoJson: boolean;

     

       14
       +
         hasExports: boolean;

     

       15
       +
         exportPath?: string;

     

       16
       +
         stats: {

     

       17
       +
           total: number;

     

       18
       +
           documented: number;

     

       19
       +
           undocumented: number;

     

       20
       +
           percentage: number;

     

       21
       +
         };

     

       22
       +
         byType?: Record<string, { total: number; documented: number }>;

     

       23
       +
       }

     

       24
       +
       

     

       25
       +
       interface WorkspaceReport {

     

       26
       +
         members: WorkspaceMemberStats[];

     

       27
       +
         aggregate: {

     

       28
       +
           totalMembers: number;

     

       29
       +
           totalExports: number;

     

       30
       +
           totalDocumented: number;

     

       31
       +
           totalUndocumented: number;

     

       32
       +
           averagePercentage: number;

     

       33
       +
         };

     

       34
       +
       }

     

       35
       +
       

     

       36
       +
       /**

     

       37
       +
        * Analyzer for Deno workspace configurations.

     

       38
       +
        *

     

       39
       +
        * The WorkspaceAnalyzer helps Doggo analyze multi-package repositories

     

       40
       +
        * by examining each workspace member individually and providing both

     

       41
       +
        * individual and aggregate documentation coverage statistics.

     

       42
       +
        *

     

       43
       +
        * @example

     

       44
       +
        * ```typescript

     

       45
       +
        * import { WorkspaceAnalyzer } from "@doggo/cli";

     

       46
       +
        *

     

       47
       +
        * const analyzer = new WorkspaceAnalyzer("./my-workspace");

     

       48
       +
        * const report = await analyzer.analyze();

     

       49
       +
        *

     

       50
       +
        * if (report) {

     

       51
       +
        *   console.log(`Total coverage: ${report.aggregate.averagePercentage}%`);

     

       52
       +
        *   console.log(`Pack members: ${report.members.length}`);

     

       53
       +
        * }

     

       54
       +
        * ```

     

       55
       +
        */

     

       56
       +
       export class WorkspaceAnalyzer {

     

       57
       +
         private rootPath: string;

     

       58
       +
         private workspaceConfig: WorkspaceConfig | null = null;

     

       59
       +
       

     

       60
       +
         constructor(rootPath: string = ".") {

     

       61
       +
           this.rootPath = resolve(rootPath);

     

       62
       +
         }

     

       63
       +
       

     

       64
       +
         async analyze(): Promise<WorkspaceReport | null> {

     

       65
       +
           // Load workspace configuration

     

       66
       +
           this.workspaceConfig = await this.loadWorkspaceConfig();

     

       67
       +
       

     

       68
       +
           if (!this.workspaceConfig?.workspace) {

     

       69
       +
             return null;

     

       70
       +
           }

     

       71
       +
       

     

       72
       +
           console.log(cyan(bold("\n🏢 Doggo is analyzing the pack!\n")));

     

       73
       +
           console.log(gray(`Root: ${this.rootPath}`));

     

       74
       +
           console.log(

     

       75
       +
             gray(`Pack members: ${this.workspaceConfig.workspace.length}\n`),

     

       76
       +
           );

     

       77
       +
       

     

       78
       +
           const members: WorkspaceMemberStats[] = [];

     

       79
       +
       

     

       80
       +
           // Analyze each workspace member

     

       81
       +
           for (const memberPath of this.workspaceConfig.workspace) {

     

       82
       +
             const fullPath = join(this.rootPath, memberPath);

     

       83
       +
             console.log(cyan(`\n🐕 Sniffing ${bold(memberPath)}...`));

     

       84
       +
       

     

       85
       +
             try {

     

       86
       +
               const stats = await this.analyzeMember(fullPath, memberPath);

     

       87
       +
               members.push(stats);

     

       88
       +
       

     

       89
       +
               // Output brief summary for this member

     

       90
       +
               this.outputMemberSummary(stats);

     

       91
       +
             } catch (error) {

     

       92
       +
               console.error(red(`  ✗ Doggo couldn't sniff ${memberPath}: ${error}`));

     

       93
       +
               // Add failed member with zero stats

     

       94
       +
               members.push({

     

       95
       +
                 name: memberPath,

     

       96
       +
                 path: fullPath,

     

       97
       +
                 hasDenoJson: false,

     

       98
       +
                 hasExports: false,

     

       99
       +
                 stats: {

     

       100
       +
                   total: 0,

     

       101
       +
                   documented: 0,

     

       102
       +
                   undocumented: 0,

     

       103
       +
                   percentage: 0,

     

       104
       +
                 },

     

       105
       +
               });

     

       106
       +
             }

     

       107
       +
           }

     

       108
       +
       

     

       109
       +
           // Calculate aggregate statistics

     

       110
       +
           const aggregate = this.calculateAggregate(members);

     

       111
       +
           const report: WorkspaceReport = { members, aggregate };

     

       112
       +
       

     

       113
       +
           // Output workspace summary

     

       114
       +
           this.outputWorkspaceSummary(report);

     

       115
       +
       

     

       116
       +
           return report;

     

       117
       +
         }

     

       118
       +
       

     

       119
       +
         private async loadWorkspaceConfig(): Promise<WorkspaceConfig | null> {

     

       120
       +
           // Try deno.json first

     

       121
       +
           const denoJsonPath = join(this.rootPath, "deno.json");

     

       122
       +
           try {

     

       123
       +
             const content = await Deno.readTextFile(denoJsonPath);

     

       124
       +
             const config = JSON.parse(content) as WorkspaceConfig;

     

       125
       +
             if (config.workspace) {

     

       126
       +
               console.log(gray(`Found workspace configuration in deno.json`));

     

       127
       +
               return config;

     

       128
       +
             }

     

       129
       +
           } catch {

     

       130
       +
             // Not found or parse error

     

       131
       +
           }

     

       132
       +
       

     

       133
       +
           // Try deno.jsonc

     

       134
       +
           const denoJsoncPath = join(this.rootPath, "deno.jsonc");

     

       135
       +
           try {

     

       136
       +
             const content = await Deno.readTextFile(denoJsoncPath);

     

       137
       +
             // Simple JSONC parsing - remove comments

     

       138
       +
             const jsonContent = content

     

       139
       +
               .split("\n")

     

       140
       +
               .map((line) => {

     

       141
       +
                 const commentIndex = line.indexOf("//");

     

       142
       +
                 return commentIndex > -1 ? line.slice(0, commentIndex) : line;

     

       143
       +
               })

     

       144
       +
               .join("\n")

     

       145
       +
               .replace(/\/\*[\s\S]*?\*\//g, "");

     

       146
       +
             const config = JSON.parse(jsonContent) as WorkspaceConfig;

     

       147
       +
             if (config.workspace) {

     

       148
       +
               console.log(gray(`Found workspace configuration in deno.jsonc`));

     

       149
       +
               return config;

     

       150
       +
             }

     

       151
       +
           } catch {

     

       152
       +
             // Not found or parse error

     

       153
       +
           }

     

       154
       +
       

     

       155
       +
           return null;

     

       156
       +
         }

     

       157
       +
       

     

       158
       +
         private async analyzeMember(

     

       159
       +
           memberPath: string,

     

       160
       +
           memberName: string,

     

       161
       +
         ): Promise<WorkspaceMemberStats> {

     

       162
       +
           // Use the core module to analyze the member

     

       163
       +
           const result = await analyzeDirectory(memberPath);

     

       164
       +
       

     

       165
       +
           return {

     

       166
       +
             name: memberName,

     

       167
       +
             path: memberPath,

     

       168
       +
             hasDenoJson: result.hasDenoJson,

     

       169
       +
             hasExports: result.hasExports,

     

       170
       +
             exportPath: result.exportPath,

     

       171
       +
             stats: {

     

       172
       +
               total: result.stats.total,

     

       173
       +
               documented: result.stats.documented,

     

       174
       +
               undocumented: result.stats.undocumented,

     

       175
       +
               percentage: result.stats.percentage,

     

       176
       +
             },

     

       177
       +
             byType: result.stats.byType,

     

       178
       +
           };

     

       179
       +
         }

     

       180
       +
       

     

       181
       +
         private outputMemberSummary(stats: WorkspaceMemberStats): void {

     

       182
       +
           const { name, hasExports, exportPath, stats: s } = stats;

     

       183
       +
       

     

       184
       +
           const percentageColor = s.percentage >= 80

     

       185
       +
             ? green

     

       186
       +
             : s.percentage >= 60

     

       187
       +
             ? yellow

     

       188
       +
             : red;

     

       189
       +
       

     

       190
       +
           const indicator = s.percentage >= 80

     

       191
       +
             ? "✓"

     

       192
       +
             : s.percentage >= 60

     

       193
       +
             ? "⚡"

     

       194
       +
             : "✗";

     

       195
       +
           const indicatorColor = s.percentage >= 80

     

       196
       +
             ? green

     

       197
       +
             : s.percentage >= 60

     

       198
       +
             ? yellow

     

       199
       +
             : red;

     

       200
       +
       

     

       201
       +
           console.log(

     

       202
       +
             `  ${indicatorColor(indicator)} ${name.padEnd(20)} ${

     

       203
       +
               s.total.toString().padStart(3)

     

       204
       +
             } exports, ${percentageColor(bold(`${s.percentage}%`))} documented`,

     

       205
       +
           );

     

       206
       +
       

     

       207
       +
           if (hasExports && exportPath) {

     

       208
       +
             console.log(gray(`    └─ Entry: ${exportPath}`));

     

       209
       +
           }

     

       210
       +
         }

     

       211
       +
       

     

       212
       +
         private calculateAggregate(

     

       213
       +
           members: WorkspaceMemberStats[],

     

       214
       +
         ): WorkspaceReport["aggregate"] {

     

       215
       +
           const totalMembers = members.length;

     

       216
       +
           const totalExports = members.reduce((sum, m) => sum + m.stats.total, 0);

     

       217
       +
           const totalDocumented = members.reduce(

     

       218
       +
             (sum, m) => sum + m.stats.documented,

     

       219
       +
             0,

     

       220
       +
           );

     

       221
       +
           const totalUndocumented = members.reduce(

     

       222
       +
             (sum, m) => sum + m.stats.undocumented,

     

       223
       +
             0,

     

       224
       +
           );

     

       225
       +
       

     

       226
       +
           // Calculate weighted average percentage

     

       227
       +
           const averagePercentage = totalExports > 0

     

       228
       +
             ? Math.round((totalDocumented / totalExports) * 100)

     

       229
       +
             : 0;

     

       230
       +
       

     

       231
       +
           return {

     

       232
       +
             totalMembers,

     

       233
       +
             totalExports,

     

       234
       +
             totalDocumented,

     

       235
       +
             totalUndocumented,

     

       236
       +
             averagePercentage,

     

       237
       +
           };

     

       238
       +
         }

     

       239
       +
       

     

       240
       +
         private outputWorkspaceSummary(report: WorkspaceReport): void {

     

       241
       +
           const { members, aggregate } = report;

     

       242
       +
       

     

       243
       +
           console.log("\n" + cyan(bold("📊 Pack Summary")));

     

       244
       +
           console.log(gray("─".repeat(60)));

     

       245
       +
       

     

       246
       +
           // Overall stats

     

       247
       +
           console.log(`\n  ${bold("Pack Statistics:")}`);

     

       248
       +
           console.log(

     

       249
       +
             `    Pack Members:      ${bold(aggregate.totalMembers.toString())}`,

     

       250
       +
           );

     

       251
       +
           console.log(

     

       252
       +
             `    Total Exports:     ${bold(aggregate.totalExports.toString())}`,

     

       253
       +
           );

     

       254
       +
           console.log(

     

       255
       +
             `    Documented:        ${green(aggregate.totalDocumented.toString())}`,

     

       256
       +
           );

     

       257
       +
           console.log(

     

       258
       +
             `    Undocumented:      ${red(aggregate.totalUndocumented.toString())}`,

     

       259
       +
           );

     

       260
       +
       

     

       261
       +
           const percentageColor = aggregate.averagePercentage >= 80

     

       262
       +
             ? green

     

       263
       +
             : aggregate.averagePercentage >= 60

     

       264
       +
             ? yellow

     

       265
       +
             : red;

     

       266
       +
           console.log(

     

       267
       +
             `    Coverage:          ${

     

       268
       +
               percentageColor(bold(`${aggregate.averagePercentage}%`))

     

       269
       +
             }`,

     

       270
       +
           );

     

       271
       +
       

     

       272
       +
           // Member breakdown table

     

       273
       +
           console.log(`\n  ${bold("Member Breakdown:")}\n`);

     

       274
       +
           console.log(gray("    " + "─".repeat(56)));

     

       275
       +
           console.log(

     

       276
       +
             gray("    │") + " Member".padEnd(20) + gray("│") + " Exports " +

     

       277
       +
               gray("│") + " Documented " + gray("│") + " Coverage " + gray("│"),

     

       278
       +
           );

     

       279
       +
           console.log(gray("    " + "─".repeat(56)));

     

       280
       +
       

     

       281
       +
           // Sort members by coverage percentage

     

       282
       +
           const sortedMembers = [...members].sort((a, b) =>

     

       283
       +
             b.stats.percentage - a.stats.percentage

     

       284
       +
           );

     

       285
       +
       

     

       286
       +
           for (const member of sortedMembers) {

     

       287
       +
             const percentageColor = member.stats.percentage >= 80

     

       288
       +
               ? green

     

       289
       +
               : member.stats.percentage >= 60

     

       290
       +
               ? yellow

     

       291
       +
               : red;

     

       292
       +
       

     

       293
       +
             const name = member.name.length > 18

     

       294
       +
               ? member.name.substring(0, 15) + "..."

     

       295
       +
               : member.name;

     

       296
       +
       

     

       297
       +
             console.log(

     

       298
       +
               gray("    │") +

     

       299
       +
                 ` ${name.padEnd(18)} ` +

     

       300
       +
                 gray("│") +

     

       301
       +
                 ` ${member.stats.total.toString().padStart(7)} ` +

     

       302
       +
                 gray("│") +

     

       303
       +
                 ` ${member.stats.documented.toString().padStart(10)} ` +

     

       304
       +
                 gray("│") +

     

       305
       +
                 ` ${

     

       306
       +
                   percentageColor(

     

       307
       +
                     member.stats.percentage.toString().padStart(7) + "%",

     

       308
       +
                   )

     

       309
       +
                 } ` +

     

       310
       +
                 gray("│"),

     

       311
       +
             );

     

       312
       +
           }

     

       313
       +
           console.log(gray("    " + "─".repeat(56)));

     

       314
       +
       

     

       315
       +
           // Identify members needing attention

     

       316
       +
           const needsWork = members.filter((m) => m.stats.percentage < 60);

     

       317
       +
           const goodCoverage = members.filter((m) => m.stats.percentage >= 80);

     

       318
       +
       

     

       319
       +
           if (needsWork.length > 0) {

     

       320
       +
             console.log(`\n  ${red("⚠️  Pack members needing training:")}`);

     

       321
       +
             for (const member of needsWork) {

     

       322
       +
               console.log(`    - ${member.name} (${member.stats.percentage}%)`);

     

       323
       +
             }

     

       324
       +
           }

     

       325
       +
       

     

       326
       +
           if (goodCoverage.length > 0) {

     

       327
       +
             console.log(`\n  ${green("✨ Kibble-worthy pups:")}`);

     

       328
       +
             for (const member of goodCoverage) {

     

       329
       +
               if (member.stats.percentage === 100) {

     

       330
       +
                 console.log(`    - ${member.name} ${green("(best in show!)")}`);

     

       331
       +
               } else {

     

       332
       +
                 console.log(`    - ${member.name} (${member.stats.percentage}%)`);

     

       333
       +
               }

     

       334
       +
             }

     

       335
       +
           }

     

       336
       +
       

     

       337
       +
           // Final indicator

     

       338
       +
           const indicator = this.getWorkspaceIndicator(aggregate.averagePercentage);

     

       339
       +
           console.log(`\n  ${indicator}\n`);

     

       340
       +
         }

     

       341
       +
       

     

       342
       +
         private getWorkspaceIndicator(percentage: number): string {

     

       343
       +
           if (percentage === 100) {

     

       344
       +
             return green("🏆 Perfect! The whole pack is doing zoomies!");

     

       345
       +
           } else if (percentage >= 90) {

     

       346
       +
             return green("✨ Excellent! The pack's tails are wagging!");

     

       347
       +
           } else if (percentage >= 80) {

     

       348
       +
             return green("👍 Good pack! Happy woofs all around");

     

       349
       +
           } else if (percentage >= 60) {

     

       350
       +
             return yellow("📈 The pack needs more training (and treats)");

     

       351
       +
           } else if (percentage >= 40) {

     

       352
       +
             return red("⚠️  Poor pack coverage (Collective sad puppy eyes)");

     

       353
       +
           } else {

     

       354
       +
             return red("🚨 Critical! The whole pack is hiding");

     

       355
       +
           }

     

       356
       +
         }

     

       357
       +
       }

     

       358
       +
       

     

       359
       +
       // CLI entry point

     

       360
       +
       async function main() {

     

       361
       +
         const analyzer = new WorkspaceAnalyzer();

     

       362
       +
         const report = await analyzer.analyze();

     

       363
       +
       

     

       364
       +
         if (!report) {

     

       365
       +
           console.log(yellow("\n⚠️  Woof! No pack configuration found."));

     

       366
       +
           console.log(

     

       367
       +
             gray(

     

       368
       +
               "Doggo was looking for 'workspace' field in deno.json or deno.jsonc\n",

     

       369
       +
             ),

     

       370
       +
           );

     

       371
       +
           Deno.exit(1);

     

       372
       +
         }

     

       373
       +
       }

     

       374
       +
       

     

       375
       +
       if (import.meta.main) {

     

       376
       +
         await main();

     

       377
       +
       }