@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/file-kinds.js

@@ -1,412 +0,0 @@
-/**
- * File Kind Detection for pi-lens
- *
- * Centralized file type detection to avoid duplication across clients.
- * Maps file extensions and paths to semantic file kinds.
- */
-import { basename, extname, win32 } from "node:path";
-import * as path from "node:path";
-import { isWindowsPath } from "./path-utils.js";
-import { findNearestDirWithMarker } from "./workspace-topology.js";
-// --- Extension Maps ---
-export const KIND_EXTENSIONS = {
-    clojure: [".clj", ".cljc", ".cljs", ".edn"],
-    cmake: [".cmake"],
-    csharp: [".cs"],
-    css: [".css", ".less", ".sass", ".scss"],
-    cue: [".cue"],
-    // From llvm-project/clang/lib/Driver/Types.cpp clang::driver::types::lookupTypeForExtension:
-    cxx: [
-        // C
-        ".c",
-        ".h",
-        // C++
-        ".c++",
-        ".cc",
-        ".cp",
-        ".cpp",
-        ".cxx",
-        ".hh",
-        ".hpp",
-        ".hxx",
-        // C++ include files
-        ".inl",
-        ".ipp",
-        ".tpp",
-        ".txx",
-        // C++20 module interface files
-        ".c++m",
-        ".cppm",
-        ".cxxm",
-        ".ixx",
-        // CUDA
-        ".cu",
-        // HIP
-        ".hip",
-        // CUDA/HIP header convention; clang's driver table omits `.cuh`, but
-        // projects use it for C++ headers that must remain in the cxx kind (#2986).
-        ".cuh",
-        // Objective-C
-        ".m",
-        ".mm",
-        // OpenCL
-        ".cl",
-        ".clcpp",
-    ],
-    dart: [".dart"],
-    docker: [".dockerfile"],
-    elixir: [".ex", ".exs"],
-    fish: [".fish"],
-    fsharp: [".fs", ".fsi", ".fsx"],
-    gleam: [".gleam"],
-    go: [".go"],
-    haskell: [".hs", ".lhs"],
-    "helm-template": [".tpl"],
-    html: [".htm", ".html"],
-    java: [".java"],
-    json: [".json", ".json5", ".jsonc"],
-    jsts: [
-        ".cjs",
-        ".cts",
-        ".js",
-        ".jsx",
-        ".mjs",
-        ".mts",
-        ".svelte",
-        ".ts",
-        ".tsx",
-        ".vue",
-    ],
-    kotlin: [".kt", ".kts"],
-    lua: [".lua"],
-    markdown: [".md", ".mdx"],
-    nix: [".nix"],
-    ocaml: [".ml", ".mli"],
-    php: [".php"],
-    powershell: [".ps1", ".psm1", ".psd1"],
-    prisma: [".prisma"],
-    python: [".py", ".pyi"],
-    ruby: [".gemspec", ".rake", ".rb", ".ru"],
-    rust: [".rs"],
-    shell: [".bash", ".sh", ".zsh"],
-    sql: [".sql"],
-    swift: [".swift"],
-    terraform: [".tf", ".tfvars"],
-    terragrunt: [],
-    toml: [".toml"],
-    yaml: [".yaml", ".yml"],
-    zig: [".zig", ".zon"],
-};
-/** Return whether a path has an extension registered for the given file kind. */
-function hasKindExtension(filePath, kind) {
-    const extension = extname(filePath).toLowerCase();
-    return KIND_EXTENSIONS[kind].some((candidate) => candidate === extension);
-}
-// Fact providers intentionally stay on the ordinary JS/TS source extensions.
-// Vue/Svelte files are classified as jsts for project-wide discovery, but their
-// embedded-language contents are not valid inputs for these tree-sitter facts.
-// Keep that one policy decision here so the function and import providers agree.
-const JSTS_FACT_EXTENSIONS = new Set(KIND_EXTENSIONS.jsts.filter((extension) => ![".vue", ".svelte"].includes(extension)));
-/** Whether the JS/TS fact providers should parse this path. */
-export function isJstsFactFile(filePath) {
-    return JSTS_FACT_EXTENSIONS.has(extname(filePath).toLowerCase());
-}
-// Bash access tracking also accepts common text/config files which do not have
-// a semantic FileKind. Every source extension is derived from KIND_EXTENSIONS;
-// only this explicit legacy text/config allowlist lives outside that registry.
-const NON_KIND_READABLE_EXTENSIONS = new Set([
-    ".txt",
-    ".env",
-    ".cfg",
-    ".conf",
-    ".ini",
-    ".xml",
-]);
-/** Whether bash file-access parsing should treat a path as source-like. */
-export function isReadableSourceFile(filePath) {
-    const extension = extname(filePath).toLowerCase();
-    return (Object.keys(KIND_EXTENSIONS).some((kind) => hasKindExtension(filePath, kind)) || NON_KIND_READABLE_EXTENSIONS.has(extension));
-}
-// --- Shared Project Root Markers ---
-/**
- * .NET project/solution root-marker globs (refs #895). Single source of truth
- * consumed by BOTH root-resolution subsystems — language-profile.ts
- * (PROJECT_MARKERS_BY_KIND / ROOT_MARKERS_BY_KIND) and lsp/server.ts
- * (CSharpServer / OmniSharpServer / FSharpServer root detectors) — following
- * the KIND_EXTENSIONS pattern: never hand-copy these lists at a call site.
- * tests/clients/dotnet-root-markers.test.ts asserts both subsystems recognize
- * every marker here, so a call site drifting from this list fails CI.
- */
-export const DOTNET_CSHARP_ROOT_MARKERS = [
-    "*.csproj",
-    "*.sln",
-    "*.slnx",
-];
-export const DOTNET_FSHARP_ROOT_MARKERS = [
-    "*.fsproj",
-    "*.sln",
-];
-/**
- * Terragrunt's unit/root entrypoint filenames, lowercase. Single source of truth
- * for every subsystem that has to agree on what counts as a terragrunt file —
- * SPECIAL_FILENAMES below, tool-policy.ts's linter and formatter policies,
- * formatters.ts's terragruntHclFormatter, and language-profile.ts's project/root
- * markers. Same rule as the .NET markers above: never hand-copy this list at a
- * call site. tests/clients/terragrunt-filenames.test.ts asserts every consumer
- * honors every name here, so a drifting call site fails CI.
- */
-export const TERRAGRUNT_FILENAMES = [
-    "terragrunt.hcl",
-    "root.hcl",
-];
-// Reverse map: extension → file kind (for fast lookup)
-const EXT_TO_KIND = new Map();
-for (const [kind, exts] of Object.entries(KIND_EXTENSIONS)) {
-    for (const ext of exts) {
-        EXT_TO_KIND.set(ext.toLowerCase(), kind);
-    }
-    // Also register without leading dot
-    for (const ext of exts) {
-        if (ext.startsWith(".")) {
-            EXT_TO_KIND.set(ext.slice(1).toLowerCase(), kind);
-        }
-    }
-}
-// Special filenames that indicate a file kind. Exported so other seams that
-// classify by basename (e.g. lsp/language.ts's language-id resolution) derive
-// from this list instead of hand-keeping their own basename literals (#1594).
-export const SPECIAL_FILENAMES = [
-    { pattern: /^CMakeLists\.txt$/i, kind: "cmake" },
-    { pattern: /^Makefile$/i, kind: "shell" },
-    { pattern: /^Dockerfile(\.\w+)?$/i, kind: "docker" },
-    ...TERRAGRUNT_FILENAMES.map((name) => ({
-        pattern: new RegExp(`^${name.replaceAll(".", "\\.")}$`, "i"),
-        kind: "terragrunt",
-    })),
-];
-// --- Detection Functions ---
-/**
- * Helm renders YAML-looking files as Go templates before they become YAML.
- * Require the shared chart-root marker before promoting a YAML template, so
- * ordinary repositories can use a `templates/` directory without entering
- * Helm dispatch. `.tpl` remains extension-classified below.
- */
-export function isHelmYamlTemplatePath(filePath) {
-    const templatesSegment = isWindowsPath(filePath)
-        ? /[\\/]templates[\\/]/i
-        : /\/templates\//i;
-    if (!templatesSegment.test(filePath) || !/\.ya?ml$/i.test(filePath)) {
-        return false;
-    }
-    const pathApi = isWindowsPath(filePath) ? win32 : path;
-    return Boolean(findNearestDirWithMarker(pathApi.dirname(filePath), "chartYamlPath"));
-}
-/**
- * Detect the file kind from a file path.
- * Returns the semantic file kind or undefined if unknown.
- */
-export function detectFileKind(filePath) {
-    if (!filePath || typeof filePath !== "string") {
-        return undefined;
-    }
-    if (isHelmYamlTemplatePath(filePath)) {
-        return "helm-template";
-    }
-    // Check special filenames first
-    const base = basename(filePath);
-    for (const { pattern, kind } of SPECIAL_FILENAMES) {
-        if (pattern.test(base)) {
-            return kind;
-        }
-    }
-    // Check by extension
-    const ext = extname(filePath).toLowerCase();
-    return EXT_TO_KIND.get(ext);
-}
-/**
- * Check if a file kind is supported by a specific tool or capability.
- *
- * @example
- * // Check if TypeScript file
- * if (isFileKind(filePath, "jsts")) { ... }
- *
- * // Check for multiple kinds
- * if (isFileKind(filePath, ["jsts", "python"])) { ... }
- */
-export function isFileKind(filePath, kind) {
-    const detected = detectFileKind(filePath);
-    if (!detected)
-        return false;
-    if (Array.isArray(kind)) {
-        return kind.includes(detected);
-    }
-    return detected === kind;
-}
-/**
- * Get all file kinds that match a given file extension.
- * Useful for listing which tools might handle a file.
- */
-export function getFileKindsForExtension(ext) {
-    const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`;
-    const kind = EXT_TO_KIND.get(normalizedExt.toLowerCase());
-    return kind ? [kind] : [];
-}
-// --- Code vs non-code kind classification (#894 review) ---------------------
-//
-// Broadened enumeration made data/doc/markup kinds (json/yaml/markdown/…)
-// visible to every project-wide walk. Those kinds must not outrank real
-// program source wherever a capped budget or a "dominant language" ranking is
-// involved: a TS repo with more .json/.yml than .ts files must still warm
-// tsserver first (#203), and 2000 locale/fixture JSON files ahead of the code
-// dirs must not exhaust a walk's file budget before any source file is seen.
-// This partition is the single authority for that distinction — every FileKind
-// MUST appear in exactly one of the two sets
-// (tests/clients/scannable-extension-coverage.test.ts enforces it, so a newly
-// registered kind cannot be silently unclassified).
-/** Kinds that are hand-written program source — prioritized in capped walks
- * and in the dominant-language LSP warm ranking. */
-export const CODE_KINDS = new Set([
-    "clojure",
-    "cmake",
-    "csharp",
-    "cue",
-    "cxx",
-    "dart",
-    "docker",
-    "elixir",
-    "fish",
-    "fsharp",
-    "gleam",
-    "go",
-    "haskell",
-    "helm-template",
-    "java",
-    "jsts",
-    "kotlin",
-    "lua",
-    "nix",
-    "ocaml",
-    "php",
-    "powershell",
-    "prisma",
-    "python",
-    "ruby",
-    "rust",
-    "shell",
-    "sql",
-    "swift",
-    "terraform",
-    "terragrunt",
-    "zig",
-]);
-/** Data/doc/markup/config kinds — still enumerated (that's #894's point), but
- * deprioritized against {@link CODE_KINDS} in budgeted walks and rankings. */
-export const NON_CODE_KINDS = new Set([
-    "css",
-    "html",
-    "json",
-    "markdown",
-    "toml",
-    "yaml",
-]);
-/**
- * Check if a file path resolves to a {@link CODE_KINDS} kind. Undetectable
- * files (unknown extension, e.g. `.coffee` from SOURCE_PRECEDENCE) are
- * non-code.
- */
-export function isCodeKindFile(filePath) {
-    const kind = detectFileKind(filePath);
-    return kind !== undefined && CODE_KINDS.has(kind);
-}
-/**
- * Get human-readable description of a file kind.
- */
-export function getFileKindLabel(kind) {
-    const labels = {
-        jsts: "JavaScript/TypeScript",
-        python: "Python",
-        go: "Go",
-        rust: "Rust",
-        cxx: "C/C++",
-        cmake: "CMake",
-        shell: "Shell",
-        json: "JSON",
-        markdown: "Markdown",
-        css: "CSS",
-        yaml: "YAML",
-        sql: "SQL",
-        ruby: "Ruby",
-        html: "HTML",
-        docker: "Dockerfile",
-        php: "PHP",
-        powershell: "PowerShell",
-        prisma: "Prisma",
-        csharp: "C#",
-        fish: "Fish shell",
-        fsharp: "F#",
-        java: "Java",
-        kotlin: "Kotlin",
-        swift: "Swift",
-        dart: "Dart",
-        lua: "Lua",
-        zig: "Zig",
-        haskell: "Haskell",
-        "helm-template": "Helm template",
-        elixir: "Elixir",
-        gleam: "Gleam",
-        ocaml: "OCaml",
-        clojure: "Clojure",
-        cue: "CUE",
-        terraform: "Terraform",
-        terragrunt: "Terragrunt",
-        nix: "Nix",
-        toml: "TOML",
-    };
-    return labels[kind] ?? kind;
-}
-/**
- * Get the language identifier for LSP/tools that use language IDs.
- */
-export function getLanguageId(kind) {
-    const languageIds = {
-        jsts: "typescript",
-        python: "python",
-        go: "go",
-        rust: "rust",
-        cxx: "cpp",
-        cmake: "cmake",
-        shell: "shell",
-        json: "json",
-        markdown: "markdown",
-        css: "css",
-        yaml: "yaml",
-        sql: "sql",
-        ruby: "ruby",
-        html: "html",
-        docker: "dockerfile",
-        php: "php",
-        powershell: "powershell",
-        prisma: "prisma",
-        csharp: "csharp",
-        fish: "fish",
-        fsharp: "fsharp",
-        java: "java",
-        kotlin: "kotlin",
-        swift: "swift",
-        dart: "dart",
-        lua: "lua",
-        zig: "zig",
-        haskell: "haskell",
-        "helm-template": "helm",
-        elixir: "elixir",
-        gleam: "gleam",
-        ocaml: "ocaml",
-        clojure: "clojure",
-        cue: "cue",
-        terraform: "terraform",
-        terragrunt: "terragrunt",
-        nix: "nix",
-        toml: "toml",
-    };
-    return languageIds[kind] ?? "plaintext";
-}

package/node_modules/pi-lens/dist/clients/file-role.js

@@ -1,134 +0,0 @@
-/**
- * File Role Classification for pi-lens
- *
- * Classifies files by their structural role in the project so runners
- * can skip checks that don't apply (e.g. no complexity checks on generated
- * files, no logic-density checks on re-export barrels).
- */
-import { basename, dirname, win32 } from "node:path";
-import { isGeneratedOrArtifact } from "./generated-artifacts.js";
-import { isWindowsPath } from "./path-utils.js";
-// --- Detection ---
-const RE_EXPORT_LINE = /^export\s+(type\s+)?\*\s+from\s+|^export\s*\{[^}]*\}\s+from\s+/;
-function isReExportBarrel(content) {
-    const lines = content
-        .split(/\r?\n/)
-        .map((l) => l.trim())
-        .filter((l) => l && !l.startsWith("//") && !l.startsWith("*") && !l.startsWith("/*"));
-    return lines.length > 0 && lines.every((l) => RE_EXPORT_LINE.test(l));
-}
-function isTypeStub(content) {
-    const lines = content
-        .split(/\r?\n/)
-        .map((l) => l.trim())
-        .filter((l) => l &&
-        !l.startsWith("//") &&
-        !l.startsWith("*") &&
-        !l.startsWith("/*") &&
-        l !== "{" &&
-        l !== "}");
-    if (lines.length < 4)
-        return false;
-    const typeOnlyLines = lines.filter((l) => /^(export\s+)?(interface|type|abstract\s+class|declare\s+(class|function|const|var|let|module|namespace|enum))\s+/.test(l) ||
-        /^(import\s+type\s+|import\s+\{)/.test(l) ||
-        /^export\s+type\s+\{/.test(l));
-    return typeOnlyLines.length / lines.length >= 0.75;
-}
-// Shared filename predicate (#2928). The parity test iterates the runner's
-// discovery table; additional conventions are pinned in file-role.test.ts.
-// Keep the case-preserved basename for CamelCase suffixes (contest.java is source).
-function testFileNameMatches(rawBase, base) {
-    return (base.includes(".test.") ||
-        base.includes(".spec.") ||
-        base.includes("_test.") ||
-        base.includes("_spec.") ||
-        base.startsWith("test_") ||
-        base.startsWith("spec_") ||
-        /(Test|Tests|TestCase)\.(java|kt|kts|cs|fs|php)$/.test(rawBase));
-}
-/** Filename-only classification for consumers with their own directory policy. */
-export function isTestFileName(filePath) {
-    const windowsShaped = isWindowsPath(filePath);
-    const rawBase = windowsShaped ? win32.basename(filePath) : basename(filePath);
-    return testFileNameMatches(rawBase, rawBase.toLowerCase());
-}
-/**
- * Classify the structural role of a file. Pass `content` for higher
- * accuracy (enables generated-code detection, barrel detection, etc.).
- *
- * `detectFileRole` is platform-native by design — normal same-OS paths
- * (POSIX on Linux, win32 on Windows) go through the module-default
- * `basename`/`dirname`, unchanged from before. But a WINDOWS-SHAPED path
- * (drive letter or UNC prefix, per `isWindowsPath`) is parsed with
- * `path.win32.basename`/`dirname` regardless of the running OS (refs #1152,
- * the #1150 class): on Linux the module-default `dirname` finds no `/` in a
- * `C:\...` path, collapses to `"."`, and the dir-based branches below
- * (`/tests/`, `/spec/`, …) silently misclassify. On win32 this branch is a
- * no-op — `win32.basename`/`dirname` already equal the module default there
- * — so native Windows classification is unchanged.
- */
-export function detectFileRole(filePath, content) {
-    const windowsShaped = isWindowsPath(filePath);
-    const rawBase = windowsShaped ? win32.basename(filePath) : basename(filePath);
-    const base = rawBase.toLowerCase();
-    const dir = (windowsShaped ? win32.dirname(filePath) : dirname(filePath))
-        .replace(/\\/g, "/")
-        .toLowerCase();
-    // --- Test ---
-    // #2928: dirname has no trailing slash; match direct __tests__ children too.
-    if (testFileNameMatches(rawBase, base) ||
-        /(^|[\\/])__tests__([\\/]|$)/.test(dir) ||
-        dir.includes("/test/") ||
-        dir.includes("/tests/") ||
-        dir.includes("/spec/") ||
-        dir.includes("/specs/") ||
-        /[/_-]tests?\/?$/.test(dir) ||
-        /[/_-]specs?\/?$/.test(dir))
-        return "test";
-    // --- Generated/artifact markers (path/name/header-based) ---
-    if (isGeneratedOrArtifact(filePath, { content, includeDeclarations: false })) {
-        return "generated";
-    }
-    // --- Migrations ---
-    // Normalize separators before regex so the pattern works on Windows too
-    const forwardDir = dir.replace(/\\/g, "/");
-    if (forwardDir.includes("/migrations/") ||
-        forwardDir.includes("/migration/") ||
-        /\/\d{4,}_[a-z]/.test(forwardDir + "/" + base))
-        return "migration";
-    // --- Config ---
-    if (base.endsWith(".config.ts") ||
-        base.endsWith(".config.js") ||
-        base.endsWith(".config.mjs") ||
-        base.endsWith(".config.cjs") ||
-        base === "vite.config.ts" ||
-        base === "jest.config.ts" ||
-        base === "jest.config.js" ||
-        base === "webpack.config.js" ||
-        base === "rollup.config.js" ||
-        base === "tailwind.config.js" ||
-        base === "tailwind.config.ts" ||
-        base === "next.config.js" ||
-        base === "next.config.mjs")
-        return "config";
-    // --- Type stubs ---
-    if (base.endsWith(".d.ts"))
-        return "stub";
-    if (content && isTypeStub(content))
-        return "stub";
-    // --- Init / barrel ---
-    const isIndexFile = base === "index.ts" ||
-        base === "index.tsx" ||
-        base === "index.js" ||
-        base === "index.mjs" ||
-        base === "index.cjs" ||
-        base === "index.jsx" ||
-        base === "__init__.py" ||
-        base === "mod.rs";
-    if (isIndexFile) {
-        if (content && isReExportBarrel(content))
-            return "re-export";
-        return "init";
-    }
-    return "source";
-}