@orangepro/orangepro-mcp 0.1.0

package/dist/local/analyze/classify.js

@@ -0,0 +1,219 @@
+const LANGUAGE_BY_EXT = {
+    ts: "typescript",
+    tsx: "typescript",
+    mts: "typescript",
+    cts: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    py: "python",
+    go: "go",
+    rb: "ruby",
+    java: "java",
+    kt: "kotlin",
+    rs: "rust",
+    php: "php",
+    cs: "csharp",
+    swift: "swift",
+    c: "c",
+    h: "c",
+    cc: "cpp",
+    cpp: "cpp",
+    cxx: "cpp",
+    hh: "cpp",
+    hpp: "cpp",
+    hxx: "cpp",
+    md: "markdown",
+    json: "json",
+    yaml: "yaml",
+    yml: "yaml",
+    toml: "toml",
+    sql: "sql"
+};
+const DOC_EXTS = new Set(["md", "mdx", "rst", "txt", "adoc"]);
+const CONFIG_BASENAMES = new Set([
+    "package.json",
+    "tsconfig.json",
+    "vitest.config.ts",
+    "vitest.config.js",
+    "jest.config.js",
+    "jest.config.ts",
+    "playwright.config.ts",
+    "playwright.config.js",
+    "cypress.config.ts",
+    "cypress.config.js",
+    "pytest.ini",
+    "tox.ini",
+    "pyproject.toml",
+    "requirements.txt",
+    "setup.cfg",
+    "go.mod",
+    "cargo.toml",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "gemfile",
+    "dockerfile",
+    ".eslintrc.js",
+    ".eslintrc.json",
+    "vite.config.ts",
+    "next.config.js",
+    "next.config.ts"
+]);
+export function extOf(relPath) {
+    const base = relPath.split("/").pop() || relPath;
+    const dot = base.lastIndexOf(".");
+    return dot >= 0 ? base.slice(dot + 1).toLowerCase() : "";
+}
+export function baseName(relPath) {
+    return (relPath.split("/").pop() || relPath).toLowerCase();
+}
+export function languageOf(relPath) {
+    return LANGUAGE_BY_EXT[extOf(relPath)] || "other";
+}
+export function isTestFile(relPath) {
+    const p = relPath.toLowerCase();
+    const file = relPath.split("/").pop() || relPath;
+    return (/\.(test|spec)\.[a-z]+$/.test(p) ||
+        /(^|\/)test\.[cm]?[jt]sx?$/.test(p) ||
+        /(^|\/)__tests__\//.test(p) ||
+        /(^|\/)(tests?|e2e|cypress|spec)\//.test(p) ||
+        /(^|\/)(unit|integration|functional|acceptance)tests?\//.test(p) ||
+        /_test\.(py|go)$/.test(p) ||
+        /test_.*\.py$/.test(p) ||
+        // Deliberately original-case: FooTests.cs is a C# test; LoadTest.cs can be product code.
+        /Tests\.[cC][sS]$/.test(file) ||
+        // Deliberately original-case: UserTest.java is a test; Latest.java is product code.
+        /(?:^Test[A-Z0-9_].*|.*(?:Test|Tests|ITCase|TestCase)|.*[a-z0-9]IT)\.(java|kt)$/.test(file) ||
+        /(?:^test_[^/]+|[^/]+_(?:test|spec))\.rb$/i.test(file));
+}
+/**
+ * Test-support files (mocks, fixtures, helpers): legitimate IMPORTS targets but
+ * never TESTED_BY/COVERS-direction linkage targets — a test exercising its own
+ * helper is not evidence that production behavior is covered.
+ */
+export function isTestSupportPath(relPath) {
+    const p = relPath.toLowerCase();
+    const base = baseName(relPath);
+    return (/(^|\/)__mocks__\//.test(p) ||
+        /(^|\/)__fixtures__\//.test(p) ||
+        /(^|\/)(mocks?|fixtures?|testdata|testlib|mock[-_][^/]+|[^/]+[-_]mock)\//.test(p) ||
+        /(^|\/)testing\/[^/]*(mock|test(?:ing)?[-_]?utils?)/.test(p) ||
+        /\.(mocks?|fixtures?)\./.test(base) ||
+        /^testdata\.[a-z0-9]+$/.test(base) ||
+        /testlib\.[a-z0-9]+$/.test(base) ||
+        /-helpers?\.[a-z0-9]+$/.test(base) ||
+        /^test[-_]/.test(base) ||
+        /^testutils?\./.test(base));
+}
+/**
+ * Test infrastructure (e2e suites, fixtures, mocks, Playwright/Cypress libs).
+ * Broader than isTestFile (which classifies an individual test); this also
+ * catches `e2e-tests/`-style harness dirs whose helper CLASSES are role:"code"
+ * but whose methods are NOT production behavior. Used ONLY to keep such class
+ * methods out of the denominator — it does not reclassify the file.
+ */
+const TEST_INFRA_DIR = /(^|\/)(e2e[-_]?tests?|e2e|__tests__|tests?|cypress|playwright|specs?|__mocks__|fixtures|testdata|testlib|test[-_]?utils?|mock[-_][^/]+|[^/]+[-_]mock)\//i;
+export function isTestInfraPath(relPath) {
+    return TEST_INFRA_DIR.test(relPath) || isTestSupportPath(relPath);
+}
+/** Plain-language reason a non-product symbol is excluded from the behavior denominator. */
+export const NON_PRODUCT_REASON = "CI/test-infra path (.github, e2e/cypress/playwright suite, mocks/fixtures/testdata/testlib) — not product behavior.";
+export const GENERATED_CODE_REASON = "Generated code (Code generated ... DO NOT EDIT) — not product-authored behavior.";
+export function isGeneratedCode(content) {
+    const lines = content.slice(0, 8192).split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        const isComment = /^(?:\/\/|#|\/\*|\*)/.test(line);
+        if (isComment) {
+            if (/\bCode generated\b/.test(line)) {
+                const window = lines
+                    .slice(i, Math.min(lines.length, i + 6))
+                    .map((l) => l.trim())
+                    .filter((l) => !l || /^(?:\/\/|#|\/\*|\*)/.test(l))
+                    .join("\n");
+                if (/DO NOT EDIT\.?/.test(window))
+                    return true;
+            }
+            continue;
+        }
+        // Go generated markers normally sit before `package`; some generators put the
+        // marker immediately after it. Once real declarations/imports begin, a marker
+        // may be part of a template string and must not classify the source file.
+        if (/^package\s+[A-Za-z_][A-Za-z0-9_]*\s*;?$/.test(line))
+            continue;
+        return false;
+    }
+    return false;
+}
+const CI_DIR = /(^|\/)\.github(\/|$)/;
+// Test-artifact DIRECTORIES anywhere — fixtures, generated mocks, Go testdata,
+// and explicit test support libraries. Matches a directory segment only.
+const INFRA_DIR_ANYWHERE = /(^|\/)(__mocks__|__fixtures__|__tests__|mocks?|fixtures?|testdata|testlib|mock[-_][^/]+|[^/]+[-_]mock)\//;
+// Test-support library files outside a dedicated test-support directory, e.g.
+// Mattermost's api4/apitestlib.go and cmd/mattermost/commands/cmdtestlib.go.
+const TESTLIB_FILE = /(^|\/)[^/]*testlib\.[a-z0-9]+$/i;
+const TESTDATA_FILE = /(^|\/)testdata\.[a-z0-9]+$/i;
+const TESTING_SUPPORT_FILE = /(^|\/)testing\/[^/]*(mock|test(?:ing)?[-_]?utils?)[^/]*\.[a-z0-9]+$/i;
+// A test SUITE at the repo ROOT (first path segment). A `playwright`/`cypress`/`e2e`
+// segment NESTED under product code (e.g. `src/playwright/`) is NOT matched.
+const ROOT_TEST_SUITE = /^(?:\.\/)?(e2e|e2e[-_]tests?|cypress|playwright|tests?|specs?)\//;
+/**
+ * A path whose exported symbols are NOT product behavior, for DENOMINATOR
+ * exclusion. Deliberately STRICTER than `isTestInfraPath` (which is a permissive
+ * test-SUPPORT-import detector): it requires real test/CI context, so product
+ * code that merely integrates Playwright (`src/playwright/runner.ts`) or has a
+ * helper-suffixed filename (`src/date-helper.ts`) is NOT excluded — over-exclusion
+ * would falsely raise coverage. No broad `scripts/`/`tools/` exclusion. Symbols
+ * here are kept as nodes with denominator_eligible:false + a reason.
+ */
+export function isNonProductPath(relPath) {
+    return (CI_DIR.test(relPath) ||
+        INFRA_DIR_ANYWHERE.test(relPath) ||
+        TESTLIB_FILE.test(relPath) ||
+        TESTDATA_FILE.test(relPath) ||
+        TESTING_SUPPORT_FILE.test(relPath) ||
+        ROOT_TEST_SUITE.test(relPath));
+}
+/**
+ * Path/name-only test-layer hint. Coarse on purpose — a LOW-confidence
+ * corroborator for the AST classifier (testLayer.ts), never the authority.
+ * Returns "unknown" when no path signal matches: a path alone NEVER asserts
+ * `unit` (the old catch-all), because that would fold unclassifiable e2e/api
+ * behaviors into the structural confirmed-%.
+ */
+export function testLayerOf(relPath) {
+    const p = relPath.toLowerCase();
+    if (/(^|\/)(e2e)\//.test(p) || /\.e2e\./.test(p) || p.includes("playwright") || p.includes("cypress"))
+        return "e2e";
+    if (/(^|\/)integration\//.test(p) || /\.integration\./.test(p) || /\.int\./.test(p))
+        return "integration";
+    if (/(^|\/)(api)\//.test(p) || /\.api\./.test(p))
+        return "api";
+    if (/\.(component|comp)\./.test(p) || p.includes("/components/"))
+        return "component";
+    if (/(^|\/)(unit)\//.test(p) || /\.(unit)\./.test(p))
+        return "unit";
+    return "unknown";
+}
+export function roleOf(relPath) {
+    const base = baseName(relPath);
+    const ext = extOf(relPath);
+    if (isTestFile(relPath))
+        return "test";
+    if (CONFIG_BASENAMES.has(base) || /\.config\.[cm]?[jt]s$/.test(base))
+        return "config";
+    if (DOC_EXTS.has(ext))
+        return "doc";
+    if (LANGUAGE_BY_EXT[ext] && ext !== "md" && ext !== "json" && ext !== "yaml" && ext !== "yml" && ext !== "toml") {
+        return "code";
+    }
+    return "other";
+}
+export function manifestKindOf(relPath) {
+    const role = roleOf(relPath);
+    return role;
+}

package/dist/local/analyze/clustering.js

@@ -0,0 +1,357 @@
+import path from "node:path";
+import { shortHash } from "../util/hash.js";
+const MAX_EMITTED_CLUSTERS = 50;
+const MAX_CLUSTER_ITEMS = 8;
+const MAX_COMPONENT_SIZE = 250;
+export function buildCallsAdjacency(nodes, edges, opts = {}) {
+    const symbolIds = new Set(nodes
+        .filter((n) => n.kind === "CodeSymbol" &&
+        n.stale !== true &&
+        (!opts.denominatorEligibleOnly || n.denominator_eligible === true))
+        .map((n) => n.external_id));
+    const adjacency = new Map();
+    for (const e of edges) {
+        if (e.relationship_type !== "CALLS")
+            continue;
+        if (e.evidence_strength !== "hard" && e.evidence_strength !== "framework-derived")
+            continue;
+        if (!symbolIds.has(e.from_external_id) || !symbolIds.has(e.to_external_id))
+            continue;
+        const item = {
+            from: e.from_external_id,
+            to: e.to_external_id,
+            evidence_strength: e.evidence_strength,
+            resolution: typeof e.properties?.resolution === "string" ? e.properties.resolution : undefined
+        };
+        const list = adjacency.get(item.from);
+        if (list)
+            list.push(item);
+        else
+            adjacency.set(item.from, [item]);
+    }
+    for (const list of adjacency.values()) {
+        list.sort((a, b) => a.to.localeCompare(b.to) ||
+            a.evidence_strength.localeCompare(b.evidence_strength) ||
+            (a.resolution ?? "").localeCompare(b.resolution ?? ""));
+    }
+    return adjacency;
+}
+class DisjointSet {
+    parent = new Map();
+    rank = new Map();
+    add(id) {
+        if (this.parent.has(id))
+            return;
+        this.parent.set(id, id);
+        this.rank.set(id, 0);
+    }
+    find(id) {
+        const p = this.parent.get(id);
+        if (!p) {
+            this.add(id);
+            return id;
+        }
+        if (p === id)
+            return id;
+        const root = this.find(p);
+        this.parent.set(id, root);
+        return root;
+    }
+    union(a, b) {
+        let ra = this.find(a);
+        let rb = this.find(b);
+        if (ra === rb)
+            return;
+        const rankA = this.rank.get(ra) ?? 0;
+        const rankB = this.rank.get(rb) ?? 0;
+        if (rankA < rankB || (rankA === rankB && ra > rb)) {
+            [ra, rb] = [rb, ra];
+        }
+        this.parent.set(rb, ra);
+        if (rankA === rankB)
+            this.rank.set(ra, rankA + 1);
+    }
+}
+function fileOfSymbol(n) {
+    const f = n.properties.file;
+    return typeof f === "string" ? f : null;
+}
+function languageOfFile(filesById, file) {
+    const lang = filesById.get(file)?.properties.language;
+    return typeof lang === "string" ? lang : "unknown";
+}
+function dirOf(file) {
+    const d = path.posix.dirname(file);
+    return d === "." ? "" : d;
+}
+function localImportPair(fromFile, toFile) {
+    const fromDir = dirOf(fromFile);
+    const toDir = dirOf(toFile);
+    if (!fromDir || !toDir)
+        return fromDir === toDir;
+    return fromDir === toDir || fromDir.startsWith(`${toDir}/`) || toDir.startsWith(`${fromDir}/`);
+}
+function titleFromFiles(files) {
+    const dirs = files.map(dirOf).filter(Boolean).sort();
+    if (dirs.length === 0)
+        return path.posix.basename(files[0] ?? "root");
+    const split = dirs.map((d) => d.split("/"));
+    const prefix = [];
+    for (let i = 0; i < split[0].length; i++) {
+        const part = split[0][i];
+        if (split.every((s) => s[i] === part))
+            prefix.push(part);
+        else
+            break;
+    }
+    const labelPath = prefix.length > 0 ? prefix.join("/") : dirs[0];
+    const last = labelPath.split("/").filter(Boolean).pop() ?? labelPath;
+    return last === labelPath ? labelPath : `${last} (${labelPath})`;
+}
+function moduleKey(file) {
+    const dir = dirOf(file);
+    if (!dir)
+        return "(root)";
+    const parts = dir.split("/").filter(Boolean);
+    const srcIdx = parts.lastIndexOf("src");
+    if (srcIdx >= 0)
+        return parts.slice(0, Math.min(parts.length, srcIdx + 3)).join("/");
+    const javaIdx = parts.lastIndexOf("java");
+    if (javaIdx >= 0)
+        return parts.slice(0, Math.min(parts.length, javaIdx + 3)).join("/");
+    const pyIdx = parts.lastIndexOf("python");
+    if (pyIdx >= 0)
+        return parts.slice(0, Math.min(parts.length, pyIdx + 3)).join("/");
+    return parts.slice(0, Math.min(parts.length, 4)).join("/");
+}
+function pathPrefix(file, depth) {
+    const dir = dirOf(file);
+    if (!dir)
+        return "(root)";
+    const parts = dir.split("/").filter(Boolean);
+    return parts.slice(0, Math.min(parts.length, depth)).join("/") || "(root)";
+}
+function splitOversizedGroup(ids, symbolById, depth = 5) {
+    if (ids.length <= MAX_COMPONENT_SIZE)
+        return [ids];
+    const byPrefix = new Map();
+    for (const id of ids) {
+        const file = fileOfSymbol(symbolById.get(id));
+        const key = file ? pathPrefix(file, depth) : "(unknown)";
+        const list = byPrefix.get(key);
+        if (list)
+            list.push(id);
+        else
+            byPrefix.set(key, [id]);
+    }
+    if (byPrefix.size <= 1) {
+        const maxDepth = Math.max(...ids.map((id) => {
+            const file = fileOfSymbol(symbolById.get(id));
+            return file ? dirOf(file).split("/").filter(Boolean).length : 0;
+        }));
+        if (depth <= maxDepth)
+            return splitOversizedGroup(ids, symbolById, depth + 1);
+        const byFile = new Map();
+        for (const id of ids) {
+            const key = fileOfSymbol(symbolById.get(id)) ?? "(unknown)";
+            const list = byFile.get(key);
+            if (list)
+                list.push(id);
+            else
+                byFile.set(key, [id]);
+        }
+        if (byFile.size > 1)
+            return [...byFile.values()].map((chunk) => chunk.sort());
+        return [ids];
+    }
+    return [...byPrefix.values()].flatMap((chunk) => splitOversizedGroup(chunk.sort(), symbolById, depth + 1));
+}
+function addCount(map, key, inc = 1) {
+    map.set(key, (map.get(key) ?? 0) + inc);
+}
+function sortedCounts(map) {
+    return Object.fromEntries([...map.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])));
+}
+function stableTop(items, limit = MAX_CLUSTER_ITEMS) {
+    return [...items].sort().slice(0, limit);
+}
+export function buildStructuralClusters(nodes, edges, candidateEdges) {
+    const filesById = new Map(nodes.filter((n) => n.kind === "File").map((n) => [n.external_id, n]));
+    const symbols = nodes.filter((n) => n.kind === "CodeSymbol" && n.denominator_eligible === true && n.stale !== true);
+    const symbolIds = new Set(symbols.map((n) => n.external_id));
+    const symbolById = new Map(symbols.map((n) => [n.external_id, n]));
+    const symbolsByFile = new Map();
+    for (const n of symbols) {
+        const file = fileOfSymbol(n);
+        if (!file)
+            continue;
+        const list = symbolsByFile.get(file);
+        if (list)
+            list.push(n.external_id);
+        else
+            symbolsByFile.set(file, [n.external_id]);
+    }
+    for (const ids of symbolsByFile.values())
+        ids.sort();
+    const dsu = new DisjointSet();
+    for (const id of symbolIds)
+        dsu.add(id);
+    // A file is the smallest structural container. Grouping its emitted behavior
+    // symbols prevents one class/file from splintering before graph edges apply.
+    for (const ids of symbolsByFile.values()) {
+        const [first, ...rest] = ids;
+        if (!first)
+            continue;
+        for (const id of rest)
+            dsu.union(first, id);
+    }
+    const links = [];
+    let hardCallEdges = 0;
+    let likelyCallEdges = 0;
+    let importEdgesConsidered = 0;
+    let importEdgesUsed = 0;
+    const importFanIn = new Map();
+    for (const e of edges) {
+        if (e.relationship_type !== "IMPORTS")
+            continue;
+        if (!symbolsByFile.has(e.from_external_id) || !symbolsByFile.has(e.to_external_id))
+            continue;
+        addCount(importFanIn, e.to_external_id);
+    }
+    const productFiles = symbolsByFile.size;
+    const importHubThreshold = Math.max(25, Math.ceil(productFiles * 0.02));
+    for (const [, outgoing] of buildCallsAdjacency(nodes, edges, { denominatorEligibleOnly: true })) {
+        for (const e of outgoing) {
+            hardCallEdges++;
+            links.push({ from: e.from, to: e.to, kind: "hard_call" });
+            dsu.union(e.from, e.to);
+        }
+    }
+    for (const e of edges) {
+        if (e.relationship_type === "IMPORTS") {
+            const fromSyms = symbolsByFile.get(e.from_external_id);
+            const toSyms = symbolsByFile.get(e.to_external_id);
+            if (!fromSyms || !toSyms || e.from_external_id === e.to_external_id)
+                continue;
+            importEdgesConsidered++;
+            if ((importFanIn.get(e.to_external_id) ?? 0) > importHubThreshold)
+                continue;
+            if (!localImportPair(e.from_external_id, e.to_external_id))
+                continue;
+            const from = fromSyms[0];
+            const to = toSyms[0];
+            if (!from || !to || from === to)
+                continue;
+            importEdgesUsed++;
+            links.push({ from, to, kind: "import" });
+            dsu.union(from, to);
+        }
+    }
+    for (const e of candidateEdges) {
+        if (e.relationship_type !== "MAY_CALL")
+            continue;
+        if (!symbolIds.has(e.from_external_id) || !symbolIds.has(e.to_external_id))
+            continue;
+        likelyCallEdges++;
+        links.push({ from: e.from_external_id, to: e.to_external_id, kind: "likely_call" });
+        dsu.union(e.from_external_id, e.to_external_id);
+    }
+    const byRoot = new Map();
+    for (const id of symbolIds) {
+        const root = dsu.find(id);
+        const list = byRoot.get(root);
+        if (list)
+            list.push(id);
+        else
+            byRoot.set(root, [id]);
+    }
+    const groups = [];
+    for (const ids of byRoot.values()) {
+        ids.sort();
+        if (ids.length <= MAX_COMPONENT_SIZE) {
+            groups.push(ids);
+            continue;
+        }
+        const byModule = new Map();
+        for (const id of ids) {
+            const file = fileOfSymbol(symbolById.get(id));
+            const key = file ? moduleKey(file) : "(unknown)";
+            const list = byModule.get(key);
+            if (list)
+                list.push(id);
+            else
+                byModule.set(key, [id]);
+        }
+        for (const chunk of byModule.values()) {
+            chunk.sort();
+            groups.push(...splitOversizedGroup(chunk, symbolById));
+        }
+    }
+    const groupBySymbol = new Map();
+    groups.forEach((ids, i) => {
+        for (const id of ids)
+            groupBySymbol.set(id, i);
+    });
+    const linkCounts = new Map();
+    for (const l of links) {
+        const a = groupBySymbol.get(l.from);
+        const b = groupBySymbol.get(l.to);
+        if (a == null || b == null || a !== b)
+            continue;
+        const counts = linkCounts.get(a) ?? { hard_calls: 0, likely_calls: 0, import_links: 0 };
+        if (l.kind === "hard_call")
+            counts.hard_calls++;
+        else if (l.kind === "likely_call")
+            counts.likely_calls++;
+        else
+            counts.import_links++;
+        linkCounts.set(a, counts);
+    }
+    const rawClusters = groups
+        .map((ids, groupIndex) => {
+        ids.sort();
+        const files = new Set();
+        const languages = new Map();
+        for (const id of ids) {
+            const file = fileOfSymbol(symbolById.get(id));
+            if (!file)
+                continue;
+            files.add(file);
+            addCount(languages, languageOfFile(filesById, file));
+        }
+        const sortedFiles = stableTop(files);
+        const counts = linkCounts.get(groupIndex) ?? { hard_calls: 0, likely_calls: 0, import_links: 0 };
+        return {
+            id: `cluster:${shortHash(ids.join("|"))}`,
+            title: titleFromFiles([...files].sort()),
+            size: ids.length,
+            files: files.size,
+            all_files: [...files].sort(),
+            languages: sortedCounts(languages),
+            top_files: sortedFiles,
+            top_symbols: stableTop(ids),
+            ...counts
+        };
+    })
+        .filter((c) => c.size >= 2)
+        .sort((a, b) => b.size - a.size ||
+        b.hard_calls + b.likely_calls + b.import_links - (a.hard_calls + a.likely_calls + a.import_links) ||
+        a.id.localeCompare(b.id));
+    const clusteredSymbols = rawClusters.reduce((sum, c) => sum + c.size, 0);
+    const clusteredFiles = new Set(rawClusters.flatMap((c) => c.all_files)).size;
+    const clusters = rawClusters.map(({ all_files, ...c }) => c);
+    const emitted = clusters.slice(0, MAX_EMITTED_CLUSTERS);
+    return {
+        method: "deterministic_components_with_path_splits",
+        total_clusters: clusters.length,
+        emitted_clusters: emitted.length,
+        clustered_symbols: clusteredSymbols,
+        clustered_files: clusteredFiles,
+        hard_call_edges: hardCallEdges,
+        likely_call_edges: likelyCallEdges,
+        import_edges_considered: importEdgesConsidered,
+        import_edges_used: importEdgesUsed,
+        import_hub_threshold: importHubThreshold,
+        clusters: emitted
+    };
+}