@orangepro/orangepro-mcp 0.2.41 → 0.2.43

package/dist/local/analyze/classify.js

@@ -75,10 +75,14 @@ export function languageOf(relPath) {
 export function isTestFile(relPath) {
     const p = relPath.toLowerCase();
     const file = relPath.split("/").pop() || relPath;
+    // CLI frameworks commonly use `src/commands/<topic>/test/` as a PRODUCT
+    // command namespace (for example `agent test run`), not as a test suite.
+    // Explicit test filenames and real test roots remain authoritative.
+    const cliTestCommandNamespace = /(^|\/)src\/commands\/(?:[^/]+\/)*test\//.test(p);
     return (/\.(test|spec)\.[a-z]+$/.test(p) ||
         /(^|\/)test\.[cm]?[jt]sx?$/.test(p) ||
         /(^|\/)__tests__\//.test(p) ||
-        /(^|\/)(tests?|e2e|cypress|spec)\//.test(p) ||
+        (!cliTestCommandNamespace && /(^|\/)(tests?|e2e|cypress|spec)\//.test(p)) ||
         /(^|\/)(unit|integration|functional|acceptance)tests?\//.test(p) ||
         /_test\.(py|go)$/.test(p) ||
         /test_.*\.py$/.test(p) ||

package/dist/local/analyze/confirm.js

@@ -572,6 +572,21 @@ export function confirmBehaviors(ctx, testAbsPath, implAbsPath, behaviorNames) {
         return out;
     }
     const implNorm = norm(implAbsPath);
+    const implSf = program.getSourceFile(implNorm);
+    const hasModifier = (node, kind) => ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((m) => m.kind === kind) ?? false);
+    const cliCommandClasses = new Set();
+    let defaultCliCommandClass = null;
+    for (const statement of implSf?.statements ?? []) {
+        if (!ts.isClassDeclaration(statement) || !statement.name)
+            continue;
+        const extendsCliCommand = statement.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword &&
+            clause.types.some((t) => /(?:^|\.)(?:Sf)?Command$/.test(t.expression.getText(implSf)))) ?? false;
+        if (!extendsCliCommand || !memberTargetsByClass.has(statement.name.text))
+            continue;
+        cliCommandClasses.add(statement.name.text);
+        if (hasModifier(statement, ts.SyntaxKind.DefaultKeyword))
+            defaultCliCommandClass = statement.name.text;
+    }
     // Resolve an identifier's binding to a terminal export name in implAbsPath, or
     // null. Follows aliases (renames, re-export barrels) to the defining file.
     const resolvedTargetName = (id) => {
@@ -918,6 +933,7 @@ export function confirmBehaviors(ctx, testAbsPath, implAbsPath, behaviorNames) {
     const constructorBindings = new Map();
     const prototypeBindings = new Map();
     const mutatorAliases = new Map();
+    const loadedModuleBindings = new Map();
     const unwrapExpression = (expr) => {
         let current = expr;
         while (ts.isParenthesizedExpression(current) ||
@@ -930,6 +946,38 @@ export function confirmBehaviors(ctx, testAbsPath, implAbsPath, behaviorNames) {
         }
         return current;
     };
+    const loadedModuleFromEsmock = (expr) => {
+        const value = unwrapExpression(expr);
+        if (!ts.isCallExpression(value) ||
+            !ts.isIdentifier(value.expression) ||
+            !importedFromPkg(value.expression, ["esmock"]) ||
+            value.arguments.length === 0) {
+            return null;
+        }
+        const spec = unwrapExpression(value.arguments[0]);
+        if (!ts.isStringLiteralLike(spec))
+            return null;
+        const resolved = resolveImport(spec.text, testAbsPath);
+        if (!resolved.resolvedFileName || norm(resolved.resolvedFileName) !== implNorm)
+            return null;
+        return {
+            src: { file: implNorm, importedName: "default", typeOnly: false },
+            defaultClassName: defaultCliCommandClass
+        };
+    };
+    const loadedDefaultClassBinding = (expr) => {
+        const value = unwrapExpression(expr);
+        if (!ts.isPropertyAccessExpression(value) || value.name.text !== "default")
+            return null;
+        const receiver = unwrapExpression(value.expression);
+        if (!ts.isIdentifier(receiver))
+            return null;
+        const sym = checker.getSymbolAtLocation(receiver);
+        const loaded = sym ? loadedModuleBindings.get(sym) : undefined;
+        if (!loaded?.defaultClassName)
+            return null;
+        return { className: loaded.defaultClassName, src: loaded.src, fromNest: false };
+    };
     const numericIndex = (expr) => {
         const index = unwrapExpression(expr);
         if (ts.isNumericLiteral(index))
@@ -1159,7 +1207,13 @@ export function confirmBehaviors(ctx, testAbsPath, implAbsPath, behaviorNames) {
         if (ts.isIdentifier(receiver)) {
             const sym = checker.getSymbolAtLocation(receiver);
             const binding = sym ? instanceBindings.get(sym) : undefined;
-            return binding ?? null;
+            if (binding)
+                return binding;
+            const directClass = classNameFromToken(receiver);
+            if (directClass && cliCommandClasses.has(directClass)) {
+                return { className: directClass, src: importSourceOf(receiver), fromNest: false };
+            }
+            return null;
         }
         if (ts.isConditionalExpression(receiver)) {
             return sameClassBinding([bindingFromNestInstanceExpr(receiver.whenTrue), bindingFromNestInstanceExpr(receiver.whenFalse)]);
@@ -1824,6 +1878,9 @@ export function confirmBehaviors(ctx, testAbsPath, implAbsPath, behaviorNames) {
     };
     const classBindingFromExpr = (expr, requireNest) => {
         const value = unwrapExpression(expr);
+        const loadedDefault = loadedDefaultClassBinding(value);
+        if (loadedDefault)
+            return loadedDefault;
         if (ts.isIdentifier(value)) {
             const sym = checker.getSymbolAtLocation(value);
             const binding = sym ? instanceBindings.get(sym) : undefined;
@@ -1856,6 +1913,22 @@ export function confirmBehaviors(ctx, testAbsPath, implAbsPath, behaviorNames) {
         if (sym)
             instanceBindings.set(sym, binding);
     };
+    const maybeBindLoadedModule = (name, expr) => {
+        const loaded = loadedModuleFromEsmock(expr);
+        if (!loaded)
+            return;
+        const sym = checker.getSymbolAtLocation(name);
+        if (sym)
+            loadedModuleBindings.set(sym, loaded);
+        if (!loaded.defaultClassName)
+            return;
+        const targetName = `${loaded.defaultClassName}.run`;
+        if (!nameSet.has(targetName))
+            return;
+        const st = stateFor(targetName);
+        st.importedRuntime = true;
+        st.importSources.push(loaded.src);
+    };
     const maybeBindDerivedIdentity = (name, expr) => {
         bindMutatorAlias(name, expr);
         const sym = checker.getSymbolAtLocation(name);
@@ -2065,6 +2138,7 @@ export function confirmBehaviors(ctx, testAbsPath, implAbsPath, behaviorNames) {
             markTupleMutationSeed(node.initializer);
             if (ts.isIdentifier(node.name)) {
                 recordContainerBindings(node.name, node.initializer);
+                maybeBindLoadedModule(node.name, node.initializer);
                 maybeBindInstance(node.name, node.initializer);
                 maybeBindDerivedIdentity(node.name, node.initializer);
             }
@@ -2395,7 +2469,10 @@ export function confirmBehaviors(ctx, testAbsPath, implAbsPath, behaviorNames) {
         out.set(name, {
             verdict: "inferred",
             reason: "the behavior is exercised but no assertion consumes its result or observes its rendered effect via the real binding",
-            rejected_conjunct: 5
+            rejected_conjunct: 5,
+            ...(st.runtimeUses.some((u) => u.src != null && cleanBindingSource(u.src) && !srcMocked(u.src))
+                ? { association_signal: "runtime_invocation" }
+                : {})
         });
     }
     return out;
@@ -2546,10 +2623,11 @@ export function resolveSpecifier(spec, fromFile, repoRoot, wsPkgs) {
 export function runConfirmer(input) {
     const { candidates, symbolsByImpl, existingSymIds, anchorFile } = input;
     const confirmations = [];
+    const associations = [];
     let attempted = 0;
     let capped_downgrades = 0;
     if (candidates.length === 0)
-        return { confirmations, attempted, capped_downgrades };
+        return { confirmations, associations, attempted, capped_downgrades };
     const absFiles = new Set();
     for (const c of candidates) {
         absFiles.add(c.testAbs);
@@ -2564,7 +2642,9 @@ export function runConfirmer(input) {
         const verdicts = confirmBehaviors(ctx, c.testAbs, c.implAbs, names);
         for (const [name, v] of verdicts) {
             attempted++;
-            if (v.verdict !== "confirmed")
+            const isConfirmed = v.verdict === "confirmed";
+            const isAssociated = v.verdict === "inferred" && v.association_signal === "runtime_invocation";
+            if (!isConfirmed && !isAssociated)
                 continue;
             const symId = `sym:${c.implRel}#${name}`;
             if (!existingSymIds.has(symId)) {
@@ -2575,8 +2655,12 @@ export function runConfirmer(input) {
             if (seen.has(key))
                 continue;
             seen.add(key);
-            confirmations.push({ testRel: c.testRel, implRel: c.implRel, behaviorName: name, symId, reason: v.reason });
+            const edge = { testRel: c.testRel, implRel: c.implRel, behaviorName: name, symId, reason: v.reason };
+            if (isConfirmed)
+                confirmations.push(edge);
+            else
+                associations.push(edge);
         }
     }
-    return { confirmations, attempted, capped_downgrades };
+    return { confirmations, associations, attempted, capped_downgrades };
 }

package/dist/local/analyze/frameworks.js

@@ -30,6 +30,9 @@ const RUNTIME_HINTS = {
     "django": "Django",
     "flask": "Flask",
     "spring-boot": "Spring Boot",
+    "@oclif/core": "oclif",
+    "@salesforce/sf-plugins-core": "Salesforce CLI",
+    "commander": "Commander",
 };
 const CONFIG_FRAMEWORK_HINTS = [
     { match: /^vitest\.config\.[tj]s$/, name: "vitest", layer: "unit" },