scip-query 0.6.9 → 0.7.0

package/dist/config-types-CGIeLEpY.d.ts

@@ -0,0 +1,108 @@
+interface InstallMethod {
+    /** Human-readable label (e.g., "npm", "pip", "go install") */
+    label: string;
+    /** Binary that must exist for this install method to work (e.g., "npm", "pip3", "go") */
+    prerequisite: string;
+    /** Command to execute */
+    binary: string;
+    /** Arguments for the command */
+    args: string[];
+}
+type SupportedLanguage = 'typescript' | 'javascript' | 'java' | 'scala' | 'kotlin' | 'rust' | 'python' | 'ruby' | 'go' | 'cpp' | 'c' | 'csharp' | 'vb' | 'dart' | 'php';
+interface IndexerConfig {
+    language: SupportedLanguage;
+    /** Preferred executable name for the indexer */
+    indexerBinary: string;
+    /** Additional executable names accepted on PATH for the same indexer */
+    binaryAliases?: string[];
+    /** Project-local executable paths to prefer when they exist */
+    projectLocalBinaries?: string[];
+    /** Command to check if the indexer is installed */
+    checkCommand: string;
+    /** Returns the binary + args array for execFileSync (no shell injection) */
+    indexArgs: (opts: {
+        projectRoot: string;
+        outputPath: string;
+        pnpmWorkspaces?: boolean;
+        indexerBinary: string;
+    }) => {
+        binary: string;
+        args: string[];
+    };
+    /** Relative output path written by the indexer when it ignores outputPath */
+    defaultOutputPath?: string;
+    /** Marker files that indicate this language is present */
+    markerFiles: string[];
+    /** Installation methods to try in order of preference */
+    installMethods?: InstallMethod[];
+    /** URL for manual installation if auto-install fails */
+    installUrl?: string;
+    /**
+     * npm package bundled with scip-query as an optionalDependency. When this
+     * package resolves locally (i.e. it installed successfully), the indexer is
+     * considered available even if its binary isn't on PATH — `npx <binary>`
+     * will pick up the local install.
+     */
+    bundledNpmPackage?: string;
+}
+interface ScipQueryConfig {
+    /** Path to the SQLite database (index.db) */
+    dbPath: string;
+    /** Path to the SCIP protobuf index (index.scip) */
+    indexPath: string;
+    /** Project root directory */
+    projectRoot: string;
+    /** Project-specific externally-live roots for dead-code filtering */
+    entryRoots?: EntryRootsConfig;
+    /** Paths to .gitignore files to load for filtering */
+    gitignorePaths?: string[];
+    /** Optional semantic-provider configuration */
+    semantic?: SemanticConfig;
+}
+interface ProjectConfig {
+    /** Override which languages to index (default: auto-detect) */
+    languages?: SupportedLanguage[];
+    /** Watch mode settings */
+    watch?: WatchConfig;
+    /** Per-language indexer overrides */
+    indexer?: Partial<Record<SupportedLanguage, IndexerOverrides>>;
+    /** Override the database storage path (default: ~/.cache/scip-query/<hash>/) */
+    dbPath?: string;
+    /** Project-specific externally-live roots for dead-code filtering */
+    entryRoots?: EntryRootsConfig;
+    /** Optional semantic-provider configuration */
+    semantic?: SemanticConfig;
+}
+interface SemanticConfig {
+    typescript?: TypeScriptSemanticConfig;
+}
+interface TypeScriptSemanticConfig {
+    /** Explicit tsconfig paths, relative to project root unless absolute */
+    tsconfigs?: string[];
+}
+interface EntryRootsConfig {
+    /** Any symbol defined in these path prefixes is externally live */
+    pathPrefixes?: string[];
+    /** Any symbol defined in these exact files is externally live */
+    files?: string[];
+    /** Symbols matching these regular expressions are externally live */
+    symbolPatterns?: string[];
+    /** Qualified var names like my.ns/my-fn that are externally live */
+    qualifiedVars?: string[];
+}
+interface WatchConfig {
+    /** Enable file watching (default: false, must opt in) */
+    enabled?: boolean;
+    /** Ms to wait after the last file change before triggering reindex (default: 30000) */
+    debounceMs?: number;
+    /** Minimum ms between reindex completions (default: 60000) */
+    cooldownMs?: number;
+    /** Extra glob patterns to ignore beyond .gitignore */
+    ignore?: string[];
+}
+interface IndexerOverrides {
+    /** Enable pnpm workspace support (TypeScript) */
+    pnpmWorkspaces?: boolean;
+}
+
+export type { IndexerConfig as I, ProjectConfig as P, ScipQueryConfig as S, SupportedLanguage as a };

package/dist/db-DdTPetj5.d.ts

@@ -0,0 +1,69 @@
+import Database from 'better-sqlite3';
+import { S as ScipQueryConfig } from './config-types-CGIeLEpY.js';
+
+/**
+ * Builds a gitignore-based path filter from .gitignore files found
+ * in the project directory tree. This replaces hardcoded path exclusions
+ * like "node_modules/", "dist/", "target/", "__pycache__/" — instead,
+ * we respect whatever the project already ignores.
+ *
+ * Falls back to sensible defaults if no .gitignore is found.
+ */
+declare function createGitignoreFilter(projectRoot: string): PathFilter;
+interface PathFilter {
+    /** Returns true if this path should be excluded from results */
+    isIgnored: (relativePath: string) => boolean;
+    /** Filter an array of paths, keeping only non-ignored ones */
+    filter: (paths: string[]) => string[];
+}
+
+/**
+ * Thin wrapper around better-sqlite3 with a pre-configured connection
+ * and helper methods for the SCIP SQLite schema.
+ *
+ * The schema is produced by `scip expt-convert` and is identical
+ * regardless of source language (TypeScript, Rust, Python, etc.).
+ *
+ * Tables:
+ *   documents             — indexed files (id, language, relative_path)
+ *   global_symbols        — all symbols (id, symbol, display_name, kind, documentation)
+ *   defn_enclosing_ranges — definition locations (document_id, symbol_id, start/end line/char)
+ *   mentions              — references & definitions (chunk_id, symbol_id, role)
+ *   chunks                — code segments (document_id, chunk_index, start/end line, occurrences)
+ */
+declare class ScipDatabase {
+    readonly db: Database.Database;
+    readonly config: ScipQueryConfig;
+    private pathFilter;
+    constructor(config: ScipQueryConfig, pathFilter?: PathFilter);
+    /** Check if a path should be excluded based on .gitignore rules */
+    isIgnored(relativePath: string): boolean;
+    /**
+     * The local-symbol predicate: only match symbols that are defined
+     * in files NOT excluded by gitignore. This replaces the old hardcoded
+     * `NOT LIKE 'node_modules/%'` check.
+     *
+     * Since SQLite can't evaluate JS gitignore rules inline, we use a
+     * simpler approach: query broadly, then filter in JS. For queries
+     * that need SQL-level filtering, use excludedPathPatterns().
+     */
+    get localSymbolPredicate(): string;
+    /**
+     * SQL WHERE clause fragments to exclude common build/dependency paths.
+     * Complements the JS-level gitignore filtering for performance.
+     */
+    get pathExclusions(): string;
+    /** Reusable SQL fragment: filter out synthetic/internal symbol noise */
+    get symbolNoise(): string;
+    /** Build SQL path exclusions for one or more document table aliases */
+    pathExclusionsFor(...aliases: string[]): string;
+    /** Build SQL symbol exclusions for the given global_symbols alias */
+    symbolNoiseFor(alias: string): string;
+    /** Run a raw SQL query and return all rows */
+    all<T = Record<string, unknown>>(sql: string, ...params: unknown[]): T[];
+    /** Run a raw SQL query and return the first row */
+    get<T = Record<string, unknown>>(sql: string, ...params: unknown[]): T | undefined;
+    close(): void;
+}
+
+export { ScipDatabase as S, createGitignoreFilter as c };

package/dist/health-x7B4Xu_6.d.ts

@@ -0,0 +1,119 @@
+import { S as ScipDatabase } from './db-DdTPetj5.js';
+import { stats } from './queries/stats.js';
+
+interface CountLocSummary {
+    count: number;
+    loc: number;
+}
+interface StaleSummary extends CountLocSummary {
+    unused: number;
+    singleUse: number;
+}
+interface DriftSummary {
+    count: number;
+    unusedImports: number;
+    layerViolations: number;
+}
+interface ComplexitySummary {
+    top: Array<{
+        symbol: string;
+        score: number;
+    }>;
+    extremeCount: number;
+}
+
+interface HealthAction {
+    category: string;
+    description: string;
+    effort: 'low' | 'medium' | 'high';
+    impact: 'low' | 'medium' | 'high';
+    count: number;
+    locRecoverable: number;
+}
+interface HealthReport {
+    score: number;
+    overview: {
+        documents: number;
+        symbols: number;
+        indexSizeBytes: number;
+    };
+    findings: {
+        deadSymbols: number;
+        deadLoc: number;
+        isolatedSymbols: number;
+        isolatedLoc: number;
+        cycles: number;
+        similarPairs: number;
+        extractionCandidates: number;
+        wrappers: number;
+        passthroughs: number;
+        staleTypes: number;
+        driftedFiles: number;
+        complexityHotspotCount: number;
+    };
+    actions: HealthAction[];
+    topComplexity: Array<{
+        symbol: string;
+        score: number;
+    }>;
+    warnings?: string[];
+}
+
+declare const HEALTH_PHASES: readonly ["overview", "dead", "isolated", "cycles", "similar", "extract-candidates", "wrapper-candidates", "passthrough-candidates", "stale-abstractions", "drift", "complexity-hotspots"];
+type HealthPhaseName = typeof HEALTH_PHASES[number];
+type HealthPhaseResult = {
+    phase: 'overview';
+    statsResult: ReturnType<typeof stats>;
+    warnings: string[];
+} | {
+    phase: 'dead';
+    dead: CountLocSummary;
+} | {
+    phase: 'isolated';
+    isolated: CountLocSummary;
+} | {
+    phase: 'cycles';
+    realCycleCount: number;
+} | {
+    phase: 'similar';
+    similarCount: number;
+} | {
+    phase: 'extract-candidates';
+    extractCount: number;
+} | {
+    phase: 'wrapper-candidates';
+    wrappers: CountLocSummary;
+} | {
+    phase: 'passthrough-candidates';
+    passthroughs: CountLocSummary;
+} | {
+    phase: 'stale-abstractions';
+    stale: StaleSummary;
+} | {
+    phase: 'drift';
+    drift: DriftSummary;
+} | {
+    phase: 'complexity-hotspots';
+    complexity: ComplexitySummary;
+};
+/**
+ * Single composite health report that runs all de-bloat analyses
+ * and produces a prioritized action list.
+ *
+ * The scoring formula accounts for common false positives:
+ * - Entry points (CLI, workers, barrels) appearing as "dead code"
+ * - Typed result interfaces with 1 consumer (normal for APIs)
+ * - Consistent import patterns across sibling modules (not duplication)
+ * - Barrel and orchestrator files deviating from sibling patterns (expected)
+ */
+declare function health(db: ScipDatabase, opts?: {
+    scope?: string;
+    full?: boolean;
+}): HealthReport;
+declare function healthPhase(db: ScipDatabase, phase: HealthPhaseName, opts?: {
+    scope?: string;
+    full?: boolean;
+}): HealthPhaseResult;
+declare function healthReportFromPhases(phaseResults: HealthPhaseResult[]): HealthReport;
+
+export { HEALTH_PHASES as H, type HealthAction as a, type HealthReport as b, healthPhase as c, healthReportFromPhases as d, type HealthPhaseName as e, health as h };