@openrewrite/rewrite 8.70.0-20251219-160440 → 8.70.0-20251219-215811

package/dist/javascript/project-parser.js

@@ -0,0 +1,726 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectParser = exports.DEFAULT_EXCLUSIONS = void 0;
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const fsp = __importStar(require("fs/promises"));
+const child_process_1 = require("child_process");
+const picomatch_1 = __importDefault(require("picomatch"));
+const immer_1 = require("immer");
+const parser_1 = require("../parser");
+const prettier_config_loader_1 = require("./format/prettier-config-loader");
+const execution_1 = require("../execution");
+// Lock file names defined here to avoid circular dependency with package-manager.ts
+// These must be kept in sync with the definitions in package-manager.ts
+const JSON_LOCK_FILE_NAMES = ['bun.lock', 'package-lock.json'];
+const YAML_LOCK_FILE_NAMES = ['pnpm-lock.yaml'];
+const TEXT_LOCK_FILE_NAMES = ['yarn.lock'];
+/**
+ * Detects if a yarn.lock file is Yarn Berry (v2+) format based on content.
+ * Yarn Berry lock files contain a `__metadata:` key which is not present in Classic.
+ */
+function isYarnBerryLockFile(content) {
+    return content.includes('__metadata:');
+}
+/**
+ * Default exclusion patterns for file discovery.
+ */
+exports.DEFAULT_EXCLUSIONS = [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.git/**",
+    "**/coverage/**",
+    "**/*.min.js",
+    "**/*.bundle.js"
+];
+/**
+ * Source file extensions for JavaScript/TypeScript.
+ */
+const SOURCE_EXTENSIONS = new Set([
+    ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"
+]);
+/**
+ * All lock file names for quick lookup.
+ */
+const ALL_LOCK_FILE_NAMES = new Set([
+    ...JSON_LOCK_FILE_NAMES,
+    ...YAML_LOCK_FILE_NAMES,
+    ...TEXT_LOCK_FILE_NAMES
+]);
+/**
+ * Plain text config files (no extension).
+ */
+const TEXT_CONFIG_FILES = new Set([
+    ".prettierignore",
+    ".gitignore",
+    ".npmignore",
+    ".eslintignore"
+]);
+/**
+ * Parses an entire JavaScript/TypeScript project.
+ *
+ * This class handles:
+ * - File discovery (source files, package.json, lock files)
+ * - Prettier configuration detection (once per project)
+ * - Parsing all files with appropriate parsers
+ * - Sharing PrettierConfigLoader across all JavaScript parsers
+ *
+ * Can be used directly for CLI tools or wrapped by RPC handlers.
+ */
+class ProjectParser {
+    constructor(projectPath, options = {}) {
+        var _a, _b, _c, _d;
+        this.projectPath = path.resolve(projectPath);
+        this.exclusions = (_a = options.exclusions) !== null && _a !== void 0 ? _a : exports.DEFAULT_EXCLUSIONS;
+        this.ctx = (_b = options.ctx) !== null && _b !== void 0 ? _b : new execution_1.ExecutionContext();
+        this.useGit = (_c = options.useGit) !== null && _c !== void 0 ? _c : this.isGitRepository();
+        this.onProgress = options.onProgress;
+        this.verbose = (_d = options.verbose) !== null && _d !== void 0 ? _d : false;
+        this.fileFilter = options.fileFilter;
+    }
+    /**
+     * Creates and initializes a PrettierConfigLoader for this project.
+     * Use this when you need to handle Prettier detection separately from parsing.
+     */
+    createPrettierLoader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log("Detecting Prettier configuration...");
+            const prettierLoader = new prettier_config_loader_1.PrettierConfigLoader(this.projectPath);
+            yield prettierLoader.detectPrettier();
+            return prettierLoader;
+        });
+    }
+    /**
+     * Builds an Autodetect marker from the given source files.
+     * Samples all files to detect common formatting styles.
+     * Uses dynamic import to avoid circular dependencies.
+     */
+    buildAutodetectMarker(sourceFiles) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Dynamic import to break circular dependency at module load time:
+            // parse-project.ts → project-parser.ts → autodetect.ts → visitor.ts → java → rpc → parse-project.ts
+            // By deferring the import until runtime, all modules are already loaded when this executes.
+            const { Autodetect } = yield import("./autodetect.js");
+            const { JS } = yield import("./tree.js");
+            const detector = Autodetect.detector();
+            for (const sf of sourceFiles) {
+                if (sf.kind === JS.Kind.CompilationUnit) {
+                    yield detector.sample(sf);
+                }
+            }
+            return detector.build();
+        });
+    }
+    /**
+     * Parses all source files in the project.
+     * Yields source files as they are parsed.
+     */
+    parse() {
+        return __asyncGenerator(this, arguments, function* parse_1() {
+            var _a, e_1, _b, _c, _d, e_2, _e, _f, _g, e_3, _h, _j, _k, e_4, _l, _m, _o, e_5, _p, _q, _r, e_6, _s, _t, _u, e_7, _v, _w, _x, e_8, _y, _z, _0, e_9, _1, _2;
+            var _3, _4, _5, _6, _7, _8, _9, _10, _11, _12;
+            // Discover files
+            this.log("Discovering files...");
+            (_3 = this.onProgress) === null || _3 === void 0 ? void 0 : _3.call(this, "discovering", 0, 0);
+            let discovered = yield __await(this.discoverFiles());
+            // Apply file filter if provided
+            if (this.fileFilter) {
+                discovered = this.applyFileFilter(discovered);
+            }
+            const totalFiles = this.countFiles(discovered);
+            this.log(`Found ${totalFiles} files to parse`);
+            // Detect Prettier configuration once for the project
+            const prettierLoader = yield __await(this.createPrettierLoader());
+            let current = 0;
+            // Parse package.json files first (they get NodeResolutionResult markers)
+            if (discovered.packageJsonFiles.length > 0) {
+                this.log(`Parsing ${discovered.packageJsonFiles.length} package.json files...`);
+                const parser = parser_1.Parsers.createParser("packageJson", {
+                    ctx: this.ctx,
+                    relativeTo: this.projectPath
+                });
+                try {
+                    for (var _13 = true, _14 = __asyncValues(parser.parse(...discovered.packageJsonFiles)), _15; _15 = yield __await(_14.next()), _a = _15.done, !_a; _13 = true) {
+                        _c = _15.value;
+                        _13 = false;
+                        const sf = _c;
+                        current++;
+                        (_4 = this.onProgress) === null || _4 === void 0 ? void 0 : _4.call(this, "parsing", current, totalFiles, sf.sourcePath);
+                        yield yield __await(sf);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_13 && !_a && (_b = _14.return)) yield __await(_b.call(_14));
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            // Parse JSON lock files
+            if (discovered.lockFiles.json.length > 0) {
+                this.log(`Parsing ${discovered.lockFiles.json.length} JSON lock files...`);
+                const parser = parser_1.Parsers.createParser("json", {
+                    ctx: this.ctx,
+                    relativeTo: this.projectPath
+                });
+                try {
+                    for (var _16 = true, _17 = __asyncValues(parser.parse(...discovered.lockFiles.json)), _18; _18 = yield __await(_17.next()), _d = _18.done, !_d; _16 = true) {
+                        _f = _18.value;
+                        _16 = false;
+                        const sf = _f;
+                        current++;
+                        (_5 = this.onProgress) === null || _5 === void 0 ? void 0 : _5.call(this, "parsing", current, totalFiles, sf.sourcePath);
+                        yield yield __await(sf);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_16 && !_d && (_e = _17.return)) yield __await(_e.call(_17));
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            // Parse YAML lock files
+            if (discovered.lockFiles.yaml.length > 0) {
+                this.log(`Parsing ${discovered.lockFiles.yaml.length} YAML lock files...`);
+                const parser = parser_1.Parsers.createParser("yaml", {
+                    ctx: this.ctx,
+                    relativeTo: this.projectPath
+                });
+                try {
+                    for (var _19 = true, _20 = __asyncValues(parser.parse(...discovered.lockFiles.yaml)), _21; _21 = yield __await(_20.next()), _g = _21.done, !_g; _19 = true) {
+                        _j = _21.value;
+                        _19 = false;
+                        const sf = _j;
+                        current++;
+                        (_6 = this.onProgress) === null || _6 === void 0 ? void 0 : _6.call(this, "parsing", current, totalFiles, sf.sourcePath);
+                        yield yield __await(sf);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (!_19 && !_g && (_h = _20.return)) yield __await(_h.call(_20));
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+            // Parse text lock files (yarn.lock Classic)
+            if (discovered.lockFiles.text.length > 0) {
+                this.log(`Parsing ${discovered.lockFiles.text.length} text lock files...`);
+                const parser = parser_1.Parsers.createParser("plainText", {
+                    ctx: this.ctx,
+                    relativeTo: this.projectPath
+                });
+                try {
+                    for (var _22 = true, _23 = __asyncValues(parser.parse(...discovered.lockFiles.text)), _24; _24 = yield __await(_23.next()), _k = _24.done, !_k; _22 = true) {
+                        _m = _24.value;
+                        _22 = false;
+                        const sf = _m;
+                        current++;
+                        (_7 = this.onProgress) === null || _7 === void 0 ? void 0 : _7.call(this, "parsing", current, totalFiles, sf.sourcePath);
+                        yield yield __await(sf);
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (!_22 && !_k && (_l = _23.return)) yield __await(_l.call(_23));
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            }
+            // Parse JavaScript/TypeScript source files
+            if (discovered.jsFiles.length > 0) {
+                this.log(`Parsing ${discovered.jsFiles.length} JavaScript/TypeScript files...`);
+                const parser = parser_1.Parsers.createParser("javascript", {
+                    ctx: this.ctx,
+                    relativeTo: this.projectPath
+                });
+                // Check if Prettier is available
+                const detection = yield __await(prettierLoader.detectPrettier());
+                if (detection.available) {
+                    try {
+                        // Prettier is available: add per-file PrettierStyle markers
+                        for (var _25 = true, _26 = __asyncValues(parser.parse(...discovered.jsFiles)), _27; _27 = yield __await(_26.next()), _o = _27.done, !_o; _25 = true) {
+                            _q = _27.value;
+                            _25 = false;
+                            const sf = _q;
+                            current++;
+                            (_8 = this.onProgress) === null || _8 === void 0 ? void 0 : _8.call(this, "parsing", current, totalFiles, sf.sourcePath);
+                            const prettierMarker = yield __await(prettierLoader.getConfigMarker(path.join(this.projectPath, sf.sourcePath)));
+                            if (prettierMarker) {
+                                yield yield __await((0, immer_1.produce)(sf, draft => {
+                                    draft.markers.markers = draft.markers.markers.concat([prettierMarker]);
+                                }));
+                            }
+                            else {
+                                yield yield __await(sf);
+                            }
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (!_25 && !_o && (_p = _26.return)) yield __await(_p.call(_26));
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                }
+                else {
+                    // Prettier is NOT available: auto-detect styles from parsed files
+                    this.log("Prettier not found, auto-detecting styles...");
+                    // Dynamic import to break circular dependency at module load time
+                    // (see buildAutodetectMarker for explanation)
+                    const { Autodetect } = yield __await(import("./autodetect.js"));
+                    const { JS } = yield __await(import("./tree.js"));
+                    const parsedFiles = [];
+                    try {
+                        // Parse all JS files and collect them for sampling
+                        for (var _28 = true, _29 = __asyncValues(parser.parse(...discovered.jsFiles)), _30; _30 = yield __await(_29.next()), _r = _30.done, !_r; _28 = true) {
+                            _t = _30.value;
+                            _28 = false;
+                            const sf = _t;
+                            current++;
+                            (_9 = this.onProgress) === null || _9 === void 0 ? void 0 : _9.call(this, "parsing", current, totalFiles, sf.sourcePath);
+                            if (sf.kind === JS.Kind.CompilationUnit) {
+                                parsedFiles.push(sf);
+                            }
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (!_28 && !_r && (_s = _29.return)) yield __await(_s.call(_29));
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                    // Sample all parsed files and build Autodetect marker
+                    const detector = Autodetect.detector();
+                    for (const sf of parsedFiles) {
+                        yield __await(detector.sample(sf));
+                    }
+                    const autodetectMarker = detector.build();
+                    this.log(`Auto-detected styles: indent=${detector.getTabsAndIndentsStyle().indentSize}, ` +
+                        `useTabs=${detector.getTabsAndIndentsStyle().useTabCharacter}`);
+                    // Yield all files with the Autodetect marker
+                    for (const sf of parsedFiles) {
+                        yield yield __await((0, immer_1.produce)(sf, draft => {
+                            draft.markers.markers = draft.markers.markers.concat([autodetectMarker]);
+                        }));
+                    }
+                }
+            }
+            // Parse other YAML files
+            if (discovered.yamlFiles.length > 0) {
+                this.log(`Parsing ${discovered.yamlFiles.length} YAML files...`);
+                const parser = parser_1.Parsers.createParser("yaml", {
+                    ctx: this.ctx,
+                    relativeTo: this.projectPath
+                });
+                try {
+                    for (var _31 = true, _32 = __asyncValues(parser.parse(...discovered.yamlFiles)), _33; _33 = yield __await(_32.next()), _u = _33.done, !_u; _31 = true) {
+                        _w = _33.value;
+                        _31 = false;
+                        const sf = _w;
+                        current++;
+                        (_10 = this.onProgress) === null || _10 === void 0 ? void 0 : _10.call(this, "parsing", current, totalFiles, sf.sourcePath);
+                        yield yield __await(sf);
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (!_31 && !_u && (_v = _32.return)) yield __await(_v.call(_32));
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+            }
+            // Parse other JSON files
+            if (discovered.jsonFiles.length > 0) {
+                this.log(`Parsing ${discovered.jsonFiles.length} JSON files...`);
+                const parser = parser_1.Parsers.createParser("json", {
+                    ctx: this.ctx,
+                    relativeTo: this.projectPath
+                });
+                try {
+                    for (var _34 = true, _35 = __asyncValues(parser.parse(...discovered.jsonFiles)), _36; _36 = yield __await(_35.next()), _x = _36.done, !_x; _34 = true) {
+                        _z = _36.value;
+                        _34 = false;
+                        const sf = _z;
+                        current++;
+                        (_11 = this.onProgress) === null || _11 === void 0 ? void 0 : _11.call(this, "parsing", current, totalFiles, sf.sourcePath);
+                        yield yield __await(sf);
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (!_34 && !_x && (_y = _35.return)) yield __await(_y.call(_35));
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+            }
+            // Parse text config files (.prettierignore, .gitignore, etc.)
+            if (discovered.textFiles.length > 0) {
+                this.log(`Parsing ${discovered.textFiles.length} text config files...`);
+                const parser = parser_1.Parsers.createParser("plainText", {
+                    ctx: this.ctx,
+                    relativeTo: this.projectPath
+                });
+                try {
+                    for (var _37 = true, _38 = __asyncValues(parser.parse(...discovered.textFiles)), _39; _39 = yield __await(_38.next()), _0 = _39.done, !_0; _37 = true) {
+                        _2 = _39.value;
+                        _37 = false;
+                        const sf = _2;
+                        current++;
+                        (_12 = this.onProgress) === null || _12 === void 0 ? void 0 : _12.call(this, "parsing", current, totalFiles, sf.sourcePath);
+                        yield yield __await(sf);
+                    }
+                }
+                catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                finally {
+                    try {
+                        if (!_37 && !_0 && (_1 = _38.return)) yield __await(_1.call(_38));
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                }
+            }
+        });
+    }
+    /**
+     * Discovers all files in the project that should be parsed.
+     */
+    discoverFiles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const discovered = {
+                packageJsonFiles: [],
+                lockFiles: {
+                    json: [],
+                    yaml: [],
+                    text: []
+                },
+                jsFiles: [],
+                jsonFiles: [],
+                yamlFiles: [],
+                textFiles: []
+            };
+            let files;
+            if (this.useGit) {
+                files = yield this.discoverFilesWithGit();
+            }
+            else {
+                files = yield this.discoverFilesWithWalk();
+            }
+            // Classify files
+            const yarnLockFiles = [];
+            for (const file of files) {
+                const basename = path.basename(file);
+                const ext = path.extname(file).toLowerCase();
+                if (basename === "package.json") {
+                    discovered.packageJsonFiles.push(file);
+                }
+                else if (SOURCE_EXTENSIONS.has(ext)) {
+                    discovered.jsFiles.push(file);
+                }
+                else if (JSON_LOCK_FILE_NAMES.includes(basename)) {
+                    discovered.lockFiles.json.push(file);
+                }
+                else if (basename === "yarn.lock") {
+                    // yarn.lock needs content-based classification
+                    yarnLockFiles.push(file);
+                }
+                else if (YAML_LOCK_FILE_NAMES.includes(basename)) {
+                    discovered.lockFiles.yaml.push(file);
+                }
+                else if (TEXT_LOCK_FILE_NAMES.includes(basename)) {
+                    discovered.lockFiles.text.push(file);
+                }
+                else if (ext === ".json") {
+                    discovered.jsonFiles.push(file);
+                }
+                else if (ext === ".yaml" || ext === ".yml") {
+                    discovered.yamlFiles.push(file);
+                }
+                else if (TEXT_CONFIG_FILES.has(basename)) {
+                    discovered.textFiles.push(file);
+                }
+            }
+            // Classify yarn.lock files by content
+            for (const yarnLockPath of yarnLockFiles) {
+                const format = yield this.classifyYarnLockFile(yarnLockPath);
+                if (format === "yaml") {
+                    discovered.lockFiles.yaml.push(yarnLockPath);
+                }
+                else {
+                    discovered.lockFiles.text.push(yarnLockPath);
+                }
+            }
+            return discovered;
+        });
+    }
+    /**
+     * Discovers files using git ls-files (respects .gitignore).
+     */
+    discoverFilesWithGit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const files = [];
+            // Get tracked files
+            const tracked = (0, child_process_1.spawnSync)("git", ["ls-files"], {
+                cwd: this.projectPath,
+                encoding: "utf8"
+            });
+            if (tracked.status !== 0 || tracked.error) {
+                // Fall back to walk if git fails
+                return this.discoverFilesWithWalk();
+            }
+            if (tracked.stdout) {
+                for (const line of tracked.stdout.split("\n")) {
+                    const trimmed = line.trim();
+                    if (trimmed) {
+                        const fullPath = path.join(this.projectPath, trimmed);
+                        // git ls-files can return deleted files that are still tracked
+                        if (fs.existsSync(fullPath)) {
+                            files.push(fullPath);
+                        }
+                    }
+                }
+            }
+            // Get untracked but not ignored files
+            const untracked = (0, child_process_1.spawnSync)("git", ["ls-files", "--others", "--exclude-standard"], {
+                cwd: this.projectPath,
+                encoding: "utf8"
+            });
+            if (untracked.stdout) {
+                for (const line of untracked.stdout.split("\n")) {
+                    const trimmed = line.trim();
+                    if (trimmed) {
+                        // Untracked files should exist, but check anyway for robustness
+                        const fullPath = path.join(this.projectPath, trimmed);
+                        if (fs.existsSync(fullPath)) {
+                            files.push(fullPath);
+                        }
+                    }
+                }
+            }
+            // Filter by our exclusion patterns and accepted file types
+            return files.filter(file => this.isAcceptedFile(file));
+        });
+    }
+    /**
+     * Discovers files by walking the directory tree.
+     */
+    discoverFilesWithWalk() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const files = [];
+            const isExcluded = (0, picomatch_1.default)(this.exclusions);
+            const walk = (dir_1, ...args_1) => __awaiter(this, [dir_1, ...args_1], void 0, function* (dir, relativePath = "") {
+                let entries;
+                try {
+                    entries = yield fsp.readdir(dir, { withFileTypes: true });
+                }
+                catch (_a) {
+                    return;
+                }
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+                    // Check exclusion patterns
+                    if (isExcluded(relPath) || isExcluded(`${relPath}/`)) {
+                        continue;
+                    }
+                    // Always skip node_modules
+                    if (entry.name === "node_modules") {
+                        continue;
+                    }
+                    if (entry.isDirectory()) {
+                        yield walk(fullPath, relPath);
+                    }
+                    else if (entry.isFile() && this.isAcceptedFile(fullPath)) {
+                        files.push(fullPath);
+                    }
+                }
+            });
+            yield walk(this.projectPath);
+            return files;
+        });
+    }
+    /**
+     * Checks if a file should be accepted for parsing.
+     */
+    isAcceptedFile(filePath) {
+        const basename = path.basename(filePath);
+        const ext = path.extname(filePath).toLowerCase();
+        // Check exclusion patterns with relative path
+        const relativePath = path.relative(this.projectPath, filePath);
+        const isExcluded = (0, picomatch_1.default)(this.exclusions);
+        if (isExcluded(relativePath)) {
+            return false;
+        }
+        // JavaScript/TypeScript files
+        if (SOURCE_EXTENSIONS.has(ext)) {
+            return true;
+        }
+        // JSON files
+        if (ext === ".json") {
+            return true;
+        }
+        // YAML files
+        if (ext === ".yaml" || ext === ".yml") {
+            return true;
+        }
+        // Lock files (some have non-standard extensions)
+        if (ALL_LOCK_FILE_NAMES.has(basename)) {
+            return true;
+        }
+        // Text config files
+        if (TEXT_CONFIG_FILES.has(basename)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Classifies a yarn.lock file as YAML (Berry) or text (Classic).
+     */
+    classifyYarnLockFile(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const content = yield fsp.readFile(filePath, "utf-8");
+                return isYarnBerryLockFile(content) ? "yaml" : "text";
+            }
+            catch (_a) {
+                return "text";
+            }
+        });
+    }
+    /**
+     * Checks if the project is a git repository.
+     */
+    isGitRepository() {
+        return fs.existsSync(path.join(this.projectPath, ".git"));
+    }
+    /**
+     * Counts total files to parse.
+     */
+    countFiles(discovered) {
+        return (discovered.packageJsonFiles.length +
+            discovered.lockFiles.json.length +
+            discovered.lockFiles.yaml.length +
+            discovered.lockFiles.text.length +
+            discovered.jsFiles.length +
+            discovered.jsonFiles.length +
+            discovered.yamlFiles.length +
+            discovered.textFiles.length);
+    }
+    /**
+     * Applies the file filter to discovered files.
+     */
+    applyFileFilter(discovered) {
+        const filter = this.fileFilter;
+        return {
+            packageJsonFiles: discovered.packageJsonFiles.filter(filter),
+            lockFiles: {
+                json: discovered.lockFiles.json.filter(filter),
+                yaml: discovered.lockFiles.yaml.filter(filter),
+                text: discovered.lockFiles.text.filter(filter)
+            },
+            jsFiles: discovered.jsFiles.filter(filter),
+            jsonFiles: discovered.jsonFiles.filter(filter),
+            yamlFiles: discovered.yamlFiles.filter(filter),
+            textFiles: discovered.textFiles.filter(filter)
+        };
+    }
+    /**
+     * Logs a message if verbose mode is enabled.
+     */
+    log(message) {
+        if (this.verbose) {
+            console.log(message);
+        }
+    }
+}
+exports.ProjectParser = ProjectParser;
+//# sourceMappingURL=project-parser.js.map