project-librarian 0.4.0 → 0.4.1

package/dist/code-index/index-health.js

@@ -0,0 +1,164 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectCodeIndexHealth = inspectCodeIndexHealth;
+exports.formatCodeIndexHealthRemediation = formatCodeIndexHealthRemediation;
+const fs = __importStar(require("node:fs"));
+function safeDiscoverCodeFiles(discoverCodeFiles, scopes) {
+    try {
+        return discoverCodeFiles(scopes).length;
+    }
+    catch {
+        return null;
+    }
+}
+function safeScalar(database, sql, param) {
+    try {
+        const rows = typeof param === "string" ? database.prepare(sql).all(param) : database.prepare(sql).all();
+        const value = rows[0]?.value;
+        return typeof value === "string" || typeof value === "number" ? String(value) : "";
+    }
+    catch {
+        return "";
+    }
+}
+function tableNames(database) {
+    try {
+        return database.prepare("SELECT name AS value FROM sqlite_schema WHERE type IN ('table', 'view') ORDER BY name")
+            .all()
+            .map((row) => String(row.value))
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function readScopes(scopesJson, scopesText, fallback) {
+    if (scopesJson) {
+        try {
+            const parsed = JSON.parse(scopesJson);
+            if (Array.isArray(parsed) && parsed.every((scope) => typeof scope === "string"))
+                return parsed;
+        }
+        catch {
+            // Fall back to legacy comma-separated metadata below.
+        }
+    }
+    const scopes = scopesText.split(",").map((scope) => scope.trim()).filter(Boolean);
+    return scopes.length > 0 ? scopes : fallback;
+}
+function rebuildCommand(indexableFiles, smallRepoThreshold) {
+    const parts = ["project-librarian", "--code-index", "--code-index-full"];
+    if (indexableFiles !== null && indexableFiles < smallRepoThreshold)
+        parts.push("--acknowledge-small-repo");
+    return parts.join(" ");
+}
+function baseHealth(options, status, message, indexableFiles) {
+    return {
+        database_path: options.relativePath,
+        expected_schema_version: options.expectedSchemaVersion,
+        found_schema_version: "",
+        indexed_files: null,
+        indexable_files: indexableFiles,
+        message,
+        parser_mode: "",
+        recommended_rebuild_command: rebuildCommand(indexableFiles, options.smallRepoThreshold),
+        scopes: options.defaultScopes,
+        status,
+        tables: [],
+        updated_at: "",
+    };
+}
+function inspectCodeIndexHealth(options) {
+    if (!fs.existsSync(options.absolutePath)) {
+        const indexableFiles = safeDiscoverCodeFiles(options.discoverCodeFiles, options.defaultScopes);
+        return baseHealth(options, "missing", `missing code evidence index: ${options.relativePath}`, indexableFiles);
+    }
+    let database;
+    try {
+        database = options.openDatabase(options.absolutePath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const indexableFiles = safeDiscoverCodeFiles(options.discoverCodeFiles, options.defaultScopes);
+        return baseHealth(options, "unreadable", `code evidence index is not readable: ${message}`, indexableFiles);
+    }
+    try {
+        database.exec("PRAGMA query_only = ON");
+        const tables = tableNames(database);
+        const foundSchemaVersion = safeScalar(database, "SELECT value FROM meta WHERE key = ?", "schema_version");
+        const updatedAt = safeScalar(database, "SELECT value FROM meta WHERE key = ?", "updated_at");
+        const parserMode = safeScalar(database, "SELECT value FROM meta WHERE key = ?", "parser_mode");
+        const scopes = readScopes(safeScalar(database, "SELECT value FROM meta WHERE key = ?", "scopes_json"), safeScalar(database, "SELECT value FROM meta WHERE key = ?", "scopes"), options.defaultScopes);
+        const indexedFilesText = tables.includes("files") ? safeScalar(database, "SELECT count(*) AS value FROM files") : "";
+        const indexedFiles = indexedFilesText ? Number(indexedFilesText) : null;
+        const indexableFiles = safeDiscoverCodeFiles(options.discoverCodeFiles, scopes.length > 0 ? scopes : options.defaultScopes);
+        const compatible = foundSchemaVersion === options.expectedSchemaVersion;
+        return {
+            database_path: options.relativePath,
+            expected_schema_version: options.expectedSchemaVersion,
+            found_schema_version: foundSchemaVersion,
+            indexed_files: indexedFiles !== null && Number.isFinite(indexedFiles) ? indexedFiles : null,
+            indexable_files: indexableFiles,
+            message: compatible
+                ? `code evidence index is compatible: schema ${foundSchemaVersion}`
+                : `code evidence index schema version ${foundSchemaVersion || "(missing)"} is incompatible with ${options.expectedSchemaVersion}`,
+            parser_mode: parserMode,
+            recommended_rebuild_command: rebuildCommand(indexableFiles, options.smallRepoThreshold),
+            scopes,
+            status: compatible ? "compatible" : "incompatible_schema",
+            tables,
+            updated_at: updatedAt,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const indexableFiles = safeDiscoverCodeFiles(options.discoverCodeFiles, options.defaultScopes);
+        return baseHealth(options, "unreadable", `code evidence index is not readable: ${message}`, indexableFiles);
+    }
+    finally {
+        database.close();
+    }
+}
+function formatCodeIndexHealthRemediation(health) {
+    return [
+        health.message,
+        `database: ${health.database_path}`,
+        `status: ${health.status}`,
+        `expected_schema_version: ${health.expected_schema_version}`,
+        `found_schema_version: ${health.found_schema_version || "(missing)"}`,
+        `rebuild: ${health.recommended_rebuild_command}`,
+    ].join("\n");
+}

package/dist/code-index/modes.js

@@ -0,0 +1,303 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCodeIndexMode = runCodeIndexMode;
+exports.runCodeQueryMode = runCodeQueryMode;
+exports.runCodeReportMode = runCodeReportMode;
+exports.runCodeStatusMode = runCodeStatusMode;
+exports.runCodeIndexHealthMode = runCodeIndexHealthMode;
+exports.runCodeFilesMode = runCodeFilesMode;
+exports.runCodeImpactMode = runCodeImpactMode;
+exports.runCodeContextPackMode = runCodeContextPackMode;
+exports.runCodeSearchSymbolMode = runCodeSearchSymbolMode;
+exports.isCodeEvidenceModeFor = isCodeEvidenceModeFor;
+exports.isCodeEvidenceMode = isCodeEvidenceMode;
+const fs = __importStar(require("node:fs"));
+const args_1 = require("../args");
+const code_index_file_policy_1 = require("../code-index-file-policy");
+const code_index_sql_1 = require("../code-index-sql");
+const reports_1 = require("./reports");
+const schema_1 = require("./schema");
+const search_1 = require("./search");
+function printRows(rows) {
+    console.log(JSON.stringify(rows, null, 2));
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function requireCompatibleDatabase(database, runtime) {
+    const schemaVersion = (0, schema_1.readMetaValue)(database, "schema_version");
+    if (schemaVersion !== schema_1.codeIndexSchemaVersion) {
+        runtime.fail(`code evidence index schema version ${schemaVersion || "(missing)"} is incompatible with ${schema_1.codeIndexSchemaVersion}; rebuild with --code-index`);
+    }
+}
+function runCodeIndexMode(runtime) {
+    const databasePath = runtime.codeEvidenceDatabasePath();
+    const scopes = runtime.codeScopes();
+    const parserMode = runtime.selectedCodeParserMode();
+    // Scale gate before ANY write or database work: below the measured threshold
+    // the build halts with the evidence-citing warning unless --acknowledge-small-repo
+    // was passed (2026-06-12 scale-aware guidance decision).
+    const discoveredFiles = (0, code_index_file_policy_1.discoverCodeFiles)(scopes);
+    const scaleGate = (0, code_index_file_policy_1.smallRepoCodeIndexGate)(discoveredFiles.length, args_1.acknowledgeSmallRepoMode);
+    if (!scaleGate.proceed)
+        runtime.fail(scaleGate.warning);
+    const existingIndex = fs.existsSync(databasePath.absolutePath);
+    if (args_1.codeIndexIncrementalMode && !existingIndex) {
+        runtime.fail(`--incremental requires an existing compatible code evidence index: ${databasePath.relativePath}`);
+    }
+    let incremental = false;
+    if (existingIndex && !args_1.codeIndexFullMode) {
+        let compatibility = { compatible: false, reason: "compatibility was not checked" };
+        const existingDatabase = runtime.openDatabase(databasePath.absolutePath);
+        try {
+            compatibility = (0, schema_1.incrementalCompatibility)(existingDatabase, scopes, parserMode);
+        }
+        finally {
+            existingDatabase.close();
+        }
+        incremental = !args_1.codeIndexFullMode && compatibility.compatible;
+        if (args_1.codeIndexIncrementalMode && !compatibility.compatible)
+            runtime.fail(`--incremental cannot update ${databasePath.relativePath}: ${compatibility.reason}`);
+    }
+    runtime.prepareOutputPath();
+    if (!incremental)
+        runtime.removeDatabaseFiles(databasePath.absolutePath);
+    const database = runtime.openDatabase(databasePath.absolutePath);
+    try {
+        if (!incremental)
+            (0, schema_1.setupDatabase)(database);
+        const statements = (0, schema_1.createIndexStatements)(database);
+        const currentFingerprints = discoveredFiles.map((filePath) => runtime.readCodeFileFingerprint(filePath));
+        let reindexedFiles;
+        let deletedPaths;
+        let indexedPaths = new Set();
+        let unchangedFiles = 0;
+        if (incremental) {
+            const indexedRows = database.prepare("SELECT path, hash, mtime_ms, size FROM files").all();
+            indexedPaths = new Set(indexedRows.map((row) => String(row.path)));
+            const indexed = new Map(indexedRows.map((row) => [String(row.path), {
+                    hash: String(row.hash),
+                    mtimeMs: Number(row.mtime_ms),
+                    size: Number(row.size),
+                }]));
+            const currentPaths = new Set(currentFingerprints.map((file) => file.path));
+            deletedPaths = indexedRows.map((row) => String(row.path)).filter((filePath) => !currentPaths.has(filePath));
+            reindexedFiles = [];
+            for (const file of currentFingerprints) {
+                const existing = indexed.get(file.path);
+                if (existing && existing.mtimeMs === file.mtimeMs && existing.size === file.size) {
+                    unchangedFiles += 1;
+                    continue;
+                }
+                reindexedFiles.push(runtime.readCodeFile(file.path, parserMode));
+            }
+        }
+        else {
+            deletedPaths = [];
+            reindexedFiles = discoveredFiles.map((filePath) => runtime.readCodeFile(filePath, parserMode));
+        }
+        database.exec("BEGIN");
+        if (!incremental)
+            statements.insertMeta.run("created_at", new Date().toISOString());
+        (0, schema_1.writeIndexMetadata)(scopes, parserMode, statements);
+        for (const filePath of deletedPaths)
+            (0, schema_1.removeIndexedFile)(filePath, statements);
+        for (const file of reindexedFiles) {
+            if (incremental && indexedPaths.has(file.path))
+                (0, schema_1.removeIndexedFile)(file.path, statements);
+            runtime.indexCodeFile(file, statements);
+        }
+        database.exec("COMMIT");
+        console.log("Project wiki code evidence index complete.");
+        console.log(`database: ${databasePath.relativePath}`);
+        console.log(`mode: ${incremental ? "incremental" : "full"}`);
+        console.log(`parser_mode: ${parserMode}`);
+        console.log(`scopes: ${scopes.join(", ")}`);
+        console.log(`files: ${currentFingerprints.length}`);
+        console.log(`reindexed_files: ${reindexedFiles.length}`);
+        console.log(`deleted_files: ${deletedPaths.length}`);
+        console.log(`unchanged_files: ${unchangedFiles}`);
+    }
+    catch (error) {
+        try {
+            database.exec("ROLLBACK");
+        }
+        catch {
+            // Ignore rollback failures after setup errors.
+        }
+        throw error;
+    }
+    finally {
+        database.close();
+    }
+}
+function runCodeQueryMode(runtime) {
+    if (!args_1.codeQuerySql.trim()) {
+        console.error("missing SQL: use --code-query \"select ...\"");
+        process.exit(1);
+    }
+    runtime.requireExistingIndex();
+    if (!(0, code_index_sql_1.isReadOnlySql)(args_1.codeQuerySql)) {
+        console.error("code queries must be read-only SQL starting with SELECT or WITH");
+        process.exit(1);
+    }
+    const database = runtime.openDatabase(runtime.codeEvidenceDatabasePath().absolutePath);
+    try {
+        database.exec("PRAGMA query_only = ON");
+        requireCompatibleDatabase(database, runtime);
+        runtime.warnIfCodeIndexStale(database);
+        printRows(database.prepare(args_1.codeQuerySql).all());
+    }
+    finally {
+        database.close();
+    }
+}
+function runCodeReportMode(runtime) {
+    runtime.requireExistingIndex();
+    const database = runtime.openDatabase(runtime.codeEvidenceDatabasePath().absolutePath);
+    try {
+        requireCompatibleDatabase(database, runtime);
+        const staleness = runtime.codeIndexStaleness(database);
+        runtime.warnIfCodeIndexStale(database, staleness);
+        const report = runtime.codeReportForRequestedSection(database, args_1.codeReportSection, { staleness });
+        if (!report)
+            runtime.fail((0, reports_1.invalidCodeReportSectionMessage)(args_1.codeReportSection));
+        printJson(report);
+    }
+    finally {
+        database.close();
+    }
+}
+function runCodeStatusMode(runtime) {
+    runtime.requireExistingIndex();
+    const database = runtime.openDatabase(runtime.codeEvidenceDatabasePath().absolutePath);
+    try {
+        requireCompatibleDatabase(database, runtime);
+        const rows = database.prepare(`
+      SELECT 'files' AS metric, count(*) AS value FROM files
+      UNION ALL SELECT 'symbols', count(*) FROM symbols
+      UNION ALL SELECT 'imports', count(*) FROM imports
+      UNION ALL SELECT 'routes', count(*) FROM routes
+      UNION ALL SELECT 'edges', count(*) FROM edges
+      UNION ALL SELECT 'configs', count(*) FROM configs
+    `).all();
+        const staleness = runtime.codeIndexStaleness(database);
+        rows.push({ metric: "stale_files", value: staleness.added + staleness.changed + staleness.deleted }, { metric: "stale_changed_files", value: staleness.changed }, { metric: "stale_added_files", value: staleness.added }, { metric: "stale_deleted_files", value: staleness.deleted });
+        printRows(rows);
+    }
+    finally {
+        database.close();
+    }
+}
+function runCodeIndexHealthMode(runtime) {
+    printJson(runtime.codeIndexHealth());
+}
+function runCodeFilesMode(runtime) {
+    runtime.requireExistingIndex();
+    const database = runtime.openDatabase(runtime.codeEvidenceDatabasePath().absolutePath);
+    try {
+        requireCompatibleDatabase(database, runtime);
+        runtime.warnIfCodeIndexStale(database);
+        printRows(database.prepare("SELECT path, language, profile, kind, lines, bytes FROM files ORDER BY path").all());
+    }
+    finally {
+        database.close();
+    }
+}
+function runCodeImpactMode(runtime) {
+    if (!args_1.codeImpactTarget.trim()) {
+        console.error("missing impact target: use --code-impact \"path-or-symbol-or-module\"");
+        process.exit(1);
+    }
+    runtime.requireExistingIndex();
+    const database = runtime.openDatabase(runtime.codeEvidenceDatabasePath().absolutePath);
+    try {
+        requireCompatibleDatabase(database, runtime);
+        const staleness = runtime.codeIndexStaleness(database);
+        runtime.warnIfCodeIndexStale(database, staleness);
+        printJson(runtime.codeImpact(database, args_1.codeImpactTarget.trim(), { staleness }));
+    }
+    finally {
+        database.close();
+    }
+}
+function runCodeContextPackMode(runtime) {
+    if (!args_1.codeContextPackTarget.trim()) {
+        console.error("missing context pack query: use --code-context-pack \"path-or-symbol-or-route\"");
+        process.exit(1);
+    }
+    runtime.requireExistingIndex();
+    const database = runtime.openDatabase(runtime.codeEvidenceDatabasePath().absolutePath);
+    try {
+        requireCompatibleDatabase(database, runtime);
+        const staleness = runtime.codeIndexStaleness(database);
+        runtime.warnIfCodeIndexStale(database, staleness);
+        console.log(runtime.codeContextPack(database, args_1.codeContextPackTarget.trim(), { staleness }));
+    }
+    finally {
+        database.close();
+    }
+}
+function runCodeSearchSymbolMode(runtime) {
+    if (!args_1.codeSearchSymbol.trim()) {
+        console.error("missing symbol search term: use --code-search-symbol \"term\"");
+        process.exit(1);
+    }
+    runtime.requireExistingIndex();
+    const database = runtime.openDatabase(runtime.codeEvidenceDatabasePath().absolutePath);
+    try {
+        requireCompatibleDatabase(database, runtime);
+        runtime.warnIfCodeIndexStale(database);
+        printRows((0, search_1.searchSymbols)(database, args_1.codeSearchSymbol.trim()));
+    }
+    finally {
+        database.close();
+    }
+}
+function isCodeEvidenceModeFor(flags) {
+    return Boolean(flags.codeContextPackTarget)
+        || Boolean(flags.codeIndexHealthMode)
+        || flags.codeIndexMode
+        || Boolean(flags.codeQuerySql)
+        || flags.codeReportMode
+        || flags.codeStatusMode
+        || flags.codeFilesMode
+        || flags.codeImpactMode
+        || Boolean(flags.codeSearchSymbol);
+}
+function isCodeEvidenceMode() {
+    return isCodeEvidenceModeFor({ codeContextPackTarget: args_1.codeContextPackTarget, codeFilesMode: args_1.codeFilesMode, codeImpactMode: args_1.codeImpactMode, codeIndexHealthMode: args_1.codeIndexHealthMode, codeIndexMode: args_1.codeIndexMode, codeQuerySql: args_1.codeQuerySql, codeReportMode: args_1.codeReportMode, codeSearchSymbol: args_1.codeSearchSymbol, codeStatusMode: args_1.codeStatusMode });
+}

package/dist/code-index/ownership.js

@@ -0,0 +1,183 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonObject = readJsonObject;
+exports.workspacePackages = workspacePackages;
+exports.matchingWorkspace = matchingWorkspace;
+exports.codeownerRules = codeownerRules;
+exports.matchedCodeownerRules = matchedCodeownerRules;
+exports.ownershipContext = ownershipContext;
+exports.ownershipInfo = ownershipInfo;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const workspace_1 = require("../workspace");
+function pathOwnerKey(filePath) {
+    const parts = (0, workspace_1.normalizePath)(filePath).split("/").filter(Boolean);
+    if (parts.length === 0)
+        return ".";
+    if (["apps", "libs", "packages", "services"].includes(parts[0] ?? "") && parts[1])
+        return `${parts[0]}/${parts[1]}`;
+    return parts[0] ?? ".";
+}
+function readJsonObject(relativePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync((0, workspace_1.abs)(relativePath), "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function workspacePatternsFromRootPackage() {
+    const rootPackage = readJsonObject("package.json");
+    const workspaces = rootPackage?.workspaces;
+    if (Array.isArray(workspaces))
+        return workspaces.filter((value) => typeof value === "string");
+    if (workspaces && typeof workspaces === "object" && !Array.isArray(workspaces)) {
+        const packages = workspaces.packages;
+        if (Array.isArray(packages))
+            return packages.filter((value) => typeof value === "string");
+    }
+    return [];
+}
+function workspacePatternCandidates(pattern) {
+    const normalized = (0, workspace_1.normalizePath)(pattern).replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!normalized || normalized.includes(".."))
+        return [];
+    if (!normalized.includes("*"))
+        return [normalized];
+    const starIndex = normalized.indexOf("*");
+    const prefix = normalized.slice(0, starIndex).replace(/\/+$/, "");
+    const suffix = normalized.slice(starIndex + 1).replace(/^\/+/, "");
+    const base = prefix || ".";
+    const basePath = (0, workspace_1.abs)(base);
+    if (!fs.existsSync(basePath) || !fs.statSync(basePath).isDirectory())
+        return [];
+    return fs.readdirSync(basePath, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => (0, workspace_1.normalizePath)(path.join(base, entry.name, suffix)))
+        .filter((candidate) => fs.existsSync((0, workspace_1.abs)(candidate)) && fs.statSync((0, workspace_1.abs)(candidate)).isDirectory());
+}
+function workspacePackages() {
+    const packages = new Map();
+    for (const pattern of workspacePatternsFromRootPackage()) {
+        for (const candidate of workspacePatternCandidates(pattern)) {
+            const packageJsonPath = (0, workspace_1.normalizePath)(path.join(candidate, "package.json"));
+            if (!fs.existsSync((0, workspace_1.abs)(packageJsonPath)))
+                continue;
+            const packageJson = readJsonObject(packageJsonPath);
+            const packageName = typeof packageJson?.name === "string" ? packageJson.name : candidate;
+            packages.set(candidate, {
+                name: packageName,
+                root: candidate,
+                source: "package.json workspaces",
+                workspace_pattern: pattern,
+            });
+        }
+    }
+    return Array.from(packages.values()).sort((left, right) => left.root.localeCompare(right.root));
+}
+function matchingWorkspace(filePath, workspaces) {
+    const normalized = (0, workspace_1.normalizePath)(filePath);
+    return workspaces
+        .filter((workspace) => normalized === workspace.root || normalized.startsWith(`${workspace.root}/`))
+        .sort((left, right) => right.root.length - left.root.length)[0] ?? null;
+}
+function codeownerRules() {
+    const files = [".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"];
+    const rules = [];
+    for (const filePath of files) {
+        if (!fs.existsSync((0, workspace_1.abs)(filePath)))
+            continue;
+        const lines = fs.readFileSync((0, workspace_1.abs)(filePath), "utf8").split(/\r?\n/);
+        lines.forEach((lineText, index) => {
+            const trimmed = lineText.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                return;
+            const parts = trimmed.split(/\s+/);
+            const pattern = parts[0] ?? "";
+            const owners = parts.slice(1);
+            if (!pattern || owners.length === 0)
+                return;
+            rules.push({ file_path: filePath, line: index + 1, owners, pattern });
+        });
+    }
+    return rules;
+}
+function codeownerPatternRegex(pattern) {
+    const normalized = (0, workspace_1.normalizePath)(pattern).replace(/^\/+/, "");
+    const source = normalized
+        .replace(/[.+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, ".*")
+        .replace(/\*/g, "[^/]*");
+    if (normalized.endsWith("/"))
+        return new RegExp(`^${source}.*$`);
+    return new RegExp(`^${source}(?:/.*)?$`);
+}
+function codeownerPatternMatches(pattern, filePath) {
+    const normalized = (0, workspace_1.normalizePath)(pattern).replace(/^\/+/, "");
+    const target = (0, workspace_1.normalizePath)(filePath);
+    if (normalized === "*")
+        return true;
+    if (normalized.startsWith("*."))
+        return path.basename(target).endsWith(normalized.slice(1));
+    return codeownerPatternRegex(normalized).test(target);
+}
+function matchingCodeowners(filePath, rules) {
+    const matches = rules.filter((rule) => codeownerPatternMatches(rule.pattern, filePath));
+    return matches[matches.length - 1]?.owners ?? [];
+}
+// Return every CODEOWNERS rule that matches a path, in file order. The last entry
+// is the effective owner under last-match-wins; earlier entries are overridden.
+// Reuses the same matcher as matchingCodeowners so precedence answers stay
+// consistent with --code-report / --code-impact.
+function matchedCodeownerRules(filePath, rules) {
+    return rules.filter((rule) => codeownerPatternMatches(rule.pattern, filePath));
+}
+function ownershipContext() {
+    return {
+        codeownerRules: codeownerRules(),
+        workspaces: workspacePackages(),
+    };
+}
+function ownershipInfo(filePath, context) {
+    const workspace = matchingWorkspace(filePath, context.workspaces);
+    const owners = matchingCodeowners(filePath, context.codeownerRules);
+    return {
+        codeowners: owners.join(", "),
+        owner: workspace?.root ?? pathOwnerKey(filePath),
+        owner_source: workspace ? "workspace" : "path",
+    };
+}