@codragraph/cli 1.6.2

package/dist/core/search/hybrid-search.js

@@ -0,0 +1,118 @@
+/**
+ * Hybrid Search with Reciprocal Rank Fusion (RRF)
+ *
+ * Combines BM25 (keyword) and semantic (embedding) search results.
+ * Uses RRF to merge rankings without needing score normalization.
+ *
+ * This is the same approach used by Elasticsearch, Pinecone, and other
+ * production search systems.
+ */
+import { searchFTSFromLbug } from './bm25-index.js';
+/**
+ * RRF constant - standard value used in the literature
+ * Higher values give more weight to lower-ranked results
+ */
+const RRF_K = 60;
+/**
+ * Perform hybrid search combining BM25 and semantic results
+ *
+ * @param bm25Results - Results from BM25 keyword search
+ * @param semanticResults - Results from semantic/embedding search
+ * @param limit - Maximum results to return
+ * @returns Merged and re-ranked results
+ */
+export const mergeWithRRF = (bm25Results, semanticResults, limit = 10) => {
+    const merged = new Map();
+    // Process BM25 results
+    for (let i = 0; i < bm25Results.length; i++) {
+        const r = bm25Results[i];
+        const rrfScore = 1 / (RRF_K + i + 1); // i+1 because rank starts at 1
+        merged.set(r.filePath, {
+            filePath: r.filePath,
+            score: rrfScore,
+            rank: 0, // Will be set after sorting
+            sources: ['bm25'],
+            bm25Score: r.score,
+        });
+    }
+    // Process semantic results and merge
+    for (let i = 0; i < semanticResults.length; i++) {
+        const r = semanticResults[i];
+        const rrfScore = 1 / (RRF_K + i + 1);
+        const existing = merged.get(r.filePath);
+        if (existing) {
+            // Found by both methods - add scores
+            existing.score += rrfScore;
+            existing.sources.push('semantic');
+            existing.semanticScore = 1 - r.distance;
+            // Add semantic metadata
+            existing.nodeId = r.nodeId;
+            existing.name = r.name;
+            existing.label = r.label;
+            existing.startLine = r.startLine;
+            existing.endLine = r.endLine;
+        }
+        else {
+            // Only found by semantic
+            merged.set(r.filePath, {
+                filePath: r.filePath,
+                score: rrfScore,
+                rank: 0,
+                sources: ['semantic'],
+                semanticScore: 1 - r.distance,
+                nodeId: r.nodeId,
+                name: r.name,
+                label: r.label,
+                startLine: r.startLine,
+                endLine: r.endLine,
+            });
+        }
+    }
+    // Sort by RRF score descending
+    const sorted = Array.from(merged.values())
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    // Assign final ranks
+    sorted.forEach((r, i) => {
+        r.rank = i + 1;
+    });
+    return sorted;
+};
+/**
+ * Check if hybrid search is available
+ * LadybugDB FTS is always available once the database is initialized.
+ * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready.
+ */
+export const isHybridSearchReady = () => {
+    return true; // FTS is always available via LadybugDB when DB is open
+};
+/**
+ * Format hybrid results for LLM consumption
+ */
+export const formatHybridResults = (results) => {
+    if (results.length === 0) {
+        return 'No results found.';
+    }
+    const formatted = results.map((r, i) => {
+        const sources = r.sources.join(' + ');
+        const location = r.startLine ? ` (lines ${r.startLine}-${r.endLine})` : '';
+        const label = r.label ? `${r.label}: ` : 'File: ';
+        const name = r.name || r.filePath.split('/').pop() || r.filePath;
+        return `[${i + 1}] ${label}${name}
+    File: ${r.filePath}${location}
+    Found by: ${sources}
+    Relevance: ${r.score.toFixed(4)}`;
+    });
+    return `Found ${results.length} results:\n\n${formatted.join('\n\n')}`;
+};
+/**
+ * Execute BM25 + semantic search and merge with RRF.
+ * Uses LadybugDB FTS for always-fresh BM25 results (no cached data).
+ * The semanticSearch function is injected to keep this module environment-agnostic.
+ */
+export const hybridSearch = async (query, limit, executeQuery, semanticSearch) => {
+    // Use LadybugDB FTS for always-fresh BM25 results
+    const bm25Results = await searchFTSFromLbug(query, limit);
+    const semanticResults = await semanticSearch(executeQuery, query, limit);
+    return mergeWithRRF(bm25Results, semanticResults, limit);
+};

package/dist/core/search/phase-timer.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Per-phase wall-clock timing for the search pipeline and similar
+ * multi-stage flows. Designed to be called from query() with minimal
+ * ceremony and negligible overhead (< 0.1 ms per phase recorded).
+ *
+ * ### Sequential usage
+ *
+ * ```ts
+ * const t = new PhaseTimer();
+ * t.start('bm25'); await bm25Search(...); t.stop();
+ * t.start('merge'); doMerge(); t.stop();
+ * const phases = t.summary(); // { bm25: 42, merge: 3 }
+ * ```
+ *
+ * ### Concurrent usage (Promise.all)
+ *
+ * `start`/`stop` assume a single active phase at a time, which is wrong
+ * for concurrent work inside `Promise.all` — the second `start` would
+ * auto-stop the first and only one of the two would get timed. Use
+ * {@link PhaseTimer.time} to wrap each concurrent promise instead:
+ *
+ * ```ts
+ * const [a, b] = await Promise.all([
+ *   t.time('bm25', bm25Search(...)),
+ *   t.time('vector', semanticSearch(...)),
+ * ]);
+ * ```
+ *
+ * ### Pre-measured durations
+ *
+ * ```ts
+ * t.mark('inherited', 12.5);
+ * ```
+ */
+export declare class PhaseTimer {
+    private phases;
+    private current;
+    private t0;
+    /** Start a new phase. Implicitly stops the previous one, if any. */
+    start(phase: string): void;
+    /** Stop the current phase. No-op if no phase is active. */
+    stop(): void;
+    /**
+     * Record a pre-measured duration without touching the active phase.
+     * Use for concurrent operations inside `Promise.all` where
+     * `start`/`stop` would step on each other, or for durations imported
+     * from sub-systems. Additive across repeated calls with the same
+     * phase name. Ignores negative / non-finite inputs.
+     */
+    mark(phase: string, durationMs: number): void;
+    /**
+     * Wrap a promise with automatic timing. Records wall time via
+     * {@link PhaseTimer.mark} regardless of which other phases are
+     * active — safe to use inside `Promise.all`.
+     */
+    time<T>(phase: string, promise: Promise<T>): Promise<T>;
+    /**
+     * Snapshot of accumulated durations rounded to 0.1 ms. Stops the
+     * current phase if one is still running.
+     */
+    summary(): Record<string, number>;
+    /**
+     * Sum of every recorded phase duration.
+     *
+     * Note: for phases recorded via {@link PhaseTimer.time} or
+     * {@link PhaseTimer.mark} this is the *sum*, not the wall time —
+     * concurrent work overlaps and the sum can exceed the end-to-end
+     * wall time. Record wall time separately with `mark('wall', …)` if
+     * that distinction matters.
+     */
+    totalMs(): number;
+}

package/dist/core/search/phase-timer.js

@@ -0,0 +1,106 @@
+/**
+ * Per-phase wall-clock timing for the search pipeline and similar
+ * multi-stage flows. Designed to be called from query() with minimal
+ * ceremony and negligible overhead (< 0.1 ms per phase recorded).
+ *
+ * ### Sequential usage
+ *
+ * ```ts
+ * const t = new PhaseTimer();
+ * t.start('bm25'); await bm25Search(...); t.stop();
+ * t.start('merge'); doMerge(); t.stop();
+ * const phases = t.summary(); // { bm25: 42, merge: 3 }
+ * ```
+ *
+ * ### Concurrent usage (Promise.all)
+ *
+ * `start`/`stop` assume a single active phase at a time, which is wrong
+ * for concurrent work inside `Promise.all` — the second `start` would
+ * auto-stop the first and only one of the two would get timed. Use
+ * {@link PhaseTimer.time} to wrap each concurrent promise instead:
+ *
+ * ```ts
+ * const [a, b] = await Promise.all([
+ *   t.time('bm25', bm25Search(...)),
+ *   t.time('vector', semanticSearch(...)),
+ * ]);
+ * ```
+ *
+ * ### Pre-measured durations
+ *
+ * ```ts
+ * t.mark('inherited', 12.5);
+ * ```
+ */
+export class PhaseTimer {
+    phases = new Map();
+    current = null;
+    t0 = 0;
+    /** Start a new phase. Implicitly stops the previous one, if any. */
+    start(phase) {
+        this.stop();
+        this.current = phase;
+        this.t0 = performance.now();
+    }
+    /** Stop the current phase. No-op if no phase is active. */
+    stop() {
+        if (this.current !== null) {
+            const elapsed = performance.now() - this.t0;
+            this.phases.set(this.current, (this.phases.get(this.current) ?? 0) + elapsed);
+            this.current = null;
+        }
+    }
+    /**
+     * Record a pre-measured duration without touching the active phase.
+     * Use for concurrent operations inside `Promise.all` where
+     * `start`/`stop` would step on each other, or for durations imported
+     * from sub-systems. Additive across repeated calls with the same
+     * phase name. Ignores negative / non-finite inputs.
+     */
+    mark(phase, durationMs) {
+        if (!Number.isFinite(durationMs) || durationMs < 0)
+            return;
+        this.phases.set(phase, (this.phases.get(phase) ?? 0) + durationMs);
+    }
+    /**
+     * Wrap a promise with automatic timing. Records wall time via
+     * {@link PhaseTimer.mark} regardless of which other phases are
+     * active — safe to use inside `Promise.all`.
+     */
+    async time(phase, promise) {
+        const t0 = performance.now();
+        try {
+            return await promise;
+        }
+        finally {
+            this.mark(phase, performance.now() - t0);
+        }
+    }
+    /**
+     * Snapshot of accumulated durations rounded to 0.1 ms. Stops the
+     * current phase if one is still running.
+     */
+    summary() {
+        this.stop();
+        const out = {};
+        for (const [k, v] of this.phases)
+            out[k] = Math.round(v * 10) / 10;
+        return out;
+    }
+    /**
+     * Sum of every recorded phase duration.
+     *
+     * Note: for phases recorded via {@link PhaseTimer.time} or
+     * {@link PhaseTimer.mark} this is the *sum*, not the wall time —
+     * concurrent work overlaps and the sum can exceed the end-to-end
+     * wall time. Record wall time separately with `mark('wall', …)` if
+     * that distinction matters.
+     */
+    totalMs() {
+        this.stop();
+        let t = 0;
+        for (const v of this.phases.values())
+            t += v;
+        return Math.round(t * 10) / 10;
+    }
+}

package/dist/core/tree-sitter/parser-loader.d.ts

@@ -0,0 +1,8 @@
+import Parser from 'tree-sitter';
+import { SupportedLanguages } from '../../_shared/index.js';
+export declare const isLanguageAvailable: (language: SupportedLanguages) => boolean;
+export declare const resolveLanguageKey: (language: SupportedLanguages, filePath?: string) => string;
+export declare const getLanguageGrammar: (language: SupportedLanguages, filePath?: string) => any;
+export declare const loadParser: () => Promise<Parser>;
+export declare const loadLanguage: (language: SupportedLanguages, filePath?: string) => Promise<void>;
+export declare const createParserForLanguage: (language: SupportedLanguages, filePath?: string) => Promise<Parser>;

package/dist/core/tree-sitter/parser-loader.js

@@ -0,0 +1,84 @@
+import Parser from 'tree-sitter';
+import JavaScript from 'tree-sitter-javascript';
+import TypeScript from 'tree-sitter-typescript';
+import Python from 'tree-sitter-python';
+import Java from 'tree-sitter-java';
+import C from 'tree-sitter-c';
+import CPP from 'tree-sitter-cpp';
+// Explicit subpath import: tree-sitter-c-sharp declares `type: "module"` with
+// `main: "bindings/node"` (no extension) and no `exports` field, which triggers
+// Node 22's DEP0151 deprecation warning on the bare-package import. Importing
+// the built entrypoint directly bypasses the deprecated ESM main-field
+// resolution. (#1013)
+import CSharp from 'tree-sitter-c-sharp/bindings/node/index.js';
+import Go from 'tree-sitter-go';
+import Rust from 'tree-sitter-rust';
+import PHP from 'tree-sitter-php';
+import Ruby from 'tree-sitter-ruby';
+import { createRequire } from 'node:module';
+import { SupportedLanguages } from '../../_shared/index.js';
+// tree-sitter-swift and tree-sitter-dart are optionalDependencies — may not be installed
+const _require = createRequire(import.meta.url);
+let Swift = null;
+try {
+    Swift = _require('tree-sitter-swift');
+}
+catch { }
+let Dart = null;
+try {
+    Dart = _require('tree-sitter-dart');
+}
+catch { }
+// tree-sitter-kotlin is an optionalDependency — may not be installed
+let Kotlin = null;
+try {
+    Kotlin = _require('tree-sitter-kotlin');
+}
+catch { }
+let parser = null;
+const languageMap = {
+    [SupportedLanguages.JavaScript]: JavaScript,
+    [SupportedLanguages.TypeScript]: TypeScript.typescript,
+    [`${SupportedLanguages.TypeScript}:tsx`]: TypeScript.tsx,
+    [SupportedLanguages.Python]: Python,
+    [SupportedLanguages.Java]: Java,
+    [SupportedLanguages.C]: C,
+    [SupportedLanguages.CPlusPlus]: CPP,
+    [SupportedLanguages.CSharp]: CSharp,
+    [SupportedLanguages.Go]: Go,
+    [SupportedLanguages.Rust]: Rust,
+    ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}),
+    [SupportedLanguages.PHP]: PHP.php_only,
+    [SupportedLanguages.Ruby]: Ruby,
+    [SupportedLanguages.Vue]: TypeScript.typescript,
+    ...(Dart ? { [SupportedLanguages.Dart]: Dart } : {}),
+    ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
+};
+export const isLanguageAvailable = (language) => language in languageMap;
+export const resolveLanguageKey = (language, filePath) => language === SupportedLanguages.TypeScript && filePath?.endsWith('.tsx')
+    ? `${language}:tsx`
+    : language;
+export const getLanguageGrammar = (language, filePath) => {
+    const key = resolveLanguageKey(language, filePath);
+    const lang = languageMap[key];
+    if (!lang) {
+        throw new Error(`Unsupported language: ${language}`);
+    }
+    return lang;
+};
+export const loadParser = async () => {
+    if (parser)
+        return parser;
+    parser = new Parser();
+    return parser;
+};
+export const loadLanguage = async (language, filePath) => {
+    if (!parser)
+        await loadParser();
+    parser.setLanguage(getLanguageGrammar(language, filePath));
+};
+export const createParserForLanguage = async (language, filePath) => {
+    const freshParser = new Parser();
+    freshParser.setLanguage(getLanguageGrammar(language, filePath));
+    return freshParser;
+};

package/dist/core/wiki/cursor-client.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Cursor CLI Client for Wiki Generation
+ *
+ * Wrapper for the Cursor headless CLI (`agent` command).
+ * Uses print mode for non-interactive LLM calls.
+ *
+ * Docs: https://cursor.com/docs/cli/headless
+ */
+import type { LLMResponse, CallLLMOptions } from './llm-client.js';
+export interface CursorConfig {
+    model?: string;
+    workingDirectory?: string;
+}
+/**
+ * Detect if Cursor CLI is available in PATH.
+ * Returns the binary name if found ('agent'), null otherwise.
+ * Result is cached after the first call.
+ */
+export declare function detectCursorCLI(): string | null;
+/**
+ * Resolve Cursor CLI configuration.
+ * Model is optional - if not provided, Cursor CLI uses its default (auto).
+ */
+export declare function resolveCursorConfig(overrides?: Partial<CursorConfig>): CursorConfig;
+/**
+ * Call the Cursor CLI in print mode.
+ *
+ * Uses `agent -p --output-format text` for clean non-streaming output.
+ * The prompt is passed as the final CLI argument.
+ */
+export declare function callCursorLLM(prompt: string, config: CursorConfig, systemPrompt?: string, options?: CallLLMOptions): Promise<LLMResponse>;

package/dist/core/wiki/cursor-client.js

@@ -0,0 +1,122 @@
+/**
+ * Cursor CLI Client for Wiki Generation
+ *
+ * Wrapper for the Cursor headless CLI (`agent` command).
+ * Uses print mode for non-interactive LLM calls.
+ *
+ * Docs: https://cursor.com/docs/cli/headless
+ */
+import { spawn, execSync } from 'child_process';
+function isVerbose() {
+    return process.env.CODRAGRAPH_VERBOSE === '1';
+}
+function verboseLog(...args) {
+    if (isVerbose()) {
+        console.log('[cursor-cli]', ...args);
+    }
+}
+let cachedCursorBin;
+/**
+ * Detect if Cursor CLI is available in PATH.
+ * Returns the binary name if found ('agent'), null otherwise.
+ * Result is cached after the first call.
+ */
+export function detectCursorCLI() {
+    if (cachedCursorBin !== undefined)
+        return cachedCursorBin;
+    try {
+        execSync('agent --version', { stdio: 'ignore' });
+        cachedCursorBin = 'agent';
+    }
+    catch {
+        cachedCursorBin = null;
+    }
+    return cachedCursorBin;
+}
+/**
+ * Resolve Cursor CLI configuration.
+ * Model is optional - if not provided, Cursor CLI uses its default (auto).
+ */
+export function resolveCursorConfig(overrides) {
+    return {
+        model: overrides?.model,
+        workingDirectory: overrides?.workingDirectory,
+    };
+}
+/**
+ * Call the Cursor CLI in print mode.
+ *
+ * Uses `agent -p --output-format text` for clean non-streaming output.
+ * The prompt is passed as the final CLI argument.
+ */
+export async function callCursorLLM(prompt, config, systemPrompt, options) {
+    const cursorBin = detectCursorCLI();
+    if (!cursorBin) {
+        throw new Error('Cursor CLI not found. Install it from https://cursor.com/docs/cli/installation');
+    }
+    // Always use text format to get clean output without agent narration/thinking.
+    // stream-json captures assistant messages which include "Let me explore..." narration
+    // that pollutes the actual content when using thinking models.
+    const fullPrompt = systemPrompt ? `${systemPrompt}\n\n---\n\n${prompt}` : prompt;
+    const args = ['-p', '--output-format', 'text'];
+    if (config.model) {
+        args.push('--model', config.model);
+    }
+    // Add the prompt as the final argument
+    args.push(fullPrompt);
+    verboseLog('Spawning:', cursorBin, args.slice(0, -1).join(' '), '[prompt length:', fullPrompt.length, 'chars]');
+    verboseLog('Working directory:', config.workingDirectory || process.cwd());
+    if (config.model) {
+        verboseLog('Model:', config.model);
+    }
+    else {
+        verboseLog('Model: auto (default)');
+    }
+    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+        const child = spawn(cursorBin, args, {
+            cwd: config.workingDirectory || process.cwd(),
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                // Ensure non-interactive mode
+                CI: '1',
+            },
+        });
+        verboseLog('Process spawned with PID:', child.pid);
+        let stdout = '';
+        let stderr = '';
+        // Text mode - collect all output, report progress based on output size
+        child.stdout.on('data', (chunk) => {
+            const chunkStr = chunk.toString();
+            stdout += chunkStr;
+            verboseLog(`[stdout] received ${chunkStr.length} chars, total: ${stdout.length}`);
+            // Report progress if callback provided
+            if (options?.onChunk) {
+                options.onChunk(stdout.length);
+            }
+        });
+        child.on('close', (code) => {
+            const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+            verboseLog(`Process exited with code ${code} after ${elapsed}s`);
+            verboseLog(`stdout length: ${stdout.length} chars`);
+            if (code !== 0) {
+                verboseLog('stderr:', stderr);
+                reject(new Error(`Cursor CLI exited with code ${code}: ${stderr}`));
+                return;
+            }
+            resolve({ content: stdout.trim() });
+        });
+        child.stderr.on('data', (chunk) => {
+            const chunkStr = chunk.toString();
+            stderr += chunkStr;
+            verboseLog('[stderr]', chunkStr.trim());
+        });
+        child.on('error', (err) => {
+            verboseLog('Spawn error:', err.message);
+            reject(new Error(`Failed to spawn Cursor CLI: ${err.message}`));
+        });
+        // Close stdin immediately since we pass prompt as argument
+        child.stdin.end();
+    });
+}

package/dist/core/wiki/generator.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Wiki Generator
+ *
+ * Orchestrates the full wiki generation pipeline:
+ *   Phase 0: Validate prerequisites + gather graph structure
+ *   Phase 1: Build module tree (one LLM call)
+ *   Phase 2: Generate module pages (one LLM call per module, bottom-up)
+ *   Phase 3: Generate overview page
+ *
+ * Supports incremental updates via git diff + module-file mapping.
+ */
+import { type LLMConfig } from './llm-client.js';
+export interface WikiOptions {
+    force?: boolean;
+    maxTokensPerModule?: number;
+    concurrency?: number;
+    /** If true, stop after building module tree for user review */
+    reviewOnly?: boolean;
+}
+export interface WikiMeta {
+    fromCommit: string;
+    generatedAt: string;
+    model: string;
+    moduleFiles: Record<string, string[]>;
+    moduleTree: ModuleTreeNode[];
+}
+export interface ModuleTreeNode {
+    name: string;
+    slug: string;
+    files: string[];
+    children?: ModuleTreeNode[];
+}
+export type ProgressCallback = (phase: string, percent: number, detail?: string) => void;
+export interface WikiRunResult {
+    pagesGenerated: number;
+    mode: 'full' | 'incremental' | 'up-to-date';
+    failedModules: string[];
+    moduleTree?: ModuleTreeNode[];
+}
+export declare class WikiGenerator {
+    private repoPath;
+    private storagePath;
+    private wikiDir;
+    private lbugPath;
+    private llmConfig;
+    private maxTokensPerModule;
+    private concurrency;
+    private options;
+    private onProgress;
+    private failedModules;
+    constructor(repoPath: string, storagePath: string, lbugPath: string, llmConfig: LLMConfig, options?: WikiOptions, onProgress?: ProgressCallback);
+    private lastPercent;
+    /**
+     * Create streaming options that report LLM progress to the progress bar.
+     *
+     * Progress calculation:
+     * - If fixedPercent is provided, we show incremental progress within that phase
+     *   based on token generation (e.g., grouping at 15% → 15-28%)
+     * - If fixedPercent is NOT provided, we only update the label with token count
+     *   but keep the current percentage (avoids fluctuation during module generation)
+     *
+     * Also touches the DB connection periodically to prevent idle timeout.
+     */
+    private streamOpts;
+    /**
+     * Route LLM call to the appropriate provider (OpenAI-compatible or Cursor CLI).
+     */
+    private invokeLLM;
+    /**
+     * Main entry point. Runs the full pipeline or incremental update.
+     */
+    run(): Promise<WikiRunResult>;
+    private ensureHTMLViewer;
+    private fullGeneration;
+    private buildModuleTree;
+    /**
+     * Parse LLM grouping response. Validates all files are assigned.
+     */
+    private parseGroupingResponse;
+    /**
+     * Fallback grouping by top-level directory when LLM parsing fails.
+     */
+    private fallbackGrouping;
+    /**
+     * Split a large module into sub-modules by subdirectory.
+     * Uses the full subDir path for naming to avoid slug collisions
+     * (e.g., "synapse-screen/src" vs "synapse-core/src").
+     */
+    private splitBySubdirectory;
+    /**
+     * Generate a leaf module page from source code + graph data.
+     */
+    private generateLeafPage;
+    /**
+     * Generate a parent module page from children's documentation.
+     */
+    private generateParentPage;
+    private generateOverview;
+    private incrementalUpdate;
+    private getCurrentCommit;
+    /**
+     * Check if fromCommit is an ancestor of toCommit (reachable in git history).
+     * Returns false if commits are on divergent branches or fromCommit doesn't exist.
+     */
+    private isCommitReachable;
+    private getChangedFiles;
+    private readSourceFiles;
+    private truncateSource;
+    private estimateModuleTokens;
+    private readProjectInfo;
+    private extractModuleFiles;
+    private countModules;
+    /**
+     * Flatten the module tree into leaf nodes and parent nodes.
+     * Leaves can be processed in parallel; parents must wait for children.
+     */
+    private flattenModuleTree;
+    /**
+     * Run async tasks in parallel with a concurrency limit and adaptive rate limiting.
+     * If a 429 rate limit is hit, concurrency is temporarily reduced.
+     */
+    private runParallel;
+    private findNodeBySlug;
+    private slugify;
+    private fileExists;
+    private loadWikiMeta;
+    private saveWikiMeta;
+    private saveModuleTree;
+}