@orangepro/orangepro-mcp 0.2.3 → 0.2.5

package/scripts/spikes/go-mutate.go

@@ -2,11 +2,16 @@
 
 // go-mutate.go — AST-based body replacer for the Go dynamic-proof spike (G-1).
 //
-// Locates ONE free function `func Name(params) rets { ... }` by exact name and
-// replaces its BODY with a signature-derived sentinel, then writes the mutated
-// file. It is a spike helper only: it writes no product artifacts and is not
-// wired into prove/RTM/mint. G-1 scope is FREE FUNCTIONS ONLY — methods
-// (`func (r Recv) M()`) are recognized and refused as out-of-scope (G-2).
+// Locates ONE function declaration by exact name — a free function `func Name(...)`
+// or a receiver method `func (r Recv) Name(...)` — and replaces its BODY with a
+// signature-derived sentinel, then writes the mutated file. Invoked by
+// go-dynamic-proof-spike.mjs (the product Go proof path); it writes ONLY the
+// mutated file inside the sandbox copy — no graph or product artifacts. The
+// name must resolve to exactly ONE declaration — in the whole file without
+// --recv, or on the selected base receiver with --recv <T> (receiver-exact
+// selection for receiver-qualified `Recv.M` targets — never the wrong decl,
+// so A.M and B.M can coexist and still be individually mutable). Ambiguity
+// within that filter fails(3); generic receivers are refused (not found).
 //
 // Modes:
 //   sentinel   — replace body with a type-compatible, deliberately-wrong value
@@ -19,9 +24,10 @@
 // Exit codes (distinct, so the Node orchestrator can classify precisely):
 //   0  ok, mutated file written
 //   2  usage / IO / parse error
-//   3  ambiguous: more than one free function with that name
-//   4  not found: no free function with that name
-//   5  out of scope: a METHOD with that name exists (G-2, refused in G-1)
+//   3  ambiguous: more than one declaration (free and/or method) with that name
+//   4  not found: no free function or method with that name
+//   5  RETIRED — was "method out of scope (G-2)" before methods became mutable;
+//      no longer emitted (kept so codes 3/4/6 stay stable for the orchestrator)
 //   6  not mutable: the function has no return values (no signature-derived
 //      sentinel is possible) -> fail closed, never mutated
 package main
@@ -51,7 +57,8 @@ func fail(code int, format string, args ...any) {
 
 func main() {
 	file := flag.String("file", "", "path to the Go source file to mutate")
-	fn := flag.String("func", "", "exact name of the free function to mutate")
+	fn := flag.String("func", "", "exact name of the free function or method to mutate")
+	recv := flag.String("recv", "", "receiver base type name; when set, match only methods on this receiver")
 	out := flag.String("out", "", "path to write the mutated file (defaults to --file)")
 	mode := flag.String("mode", "sentinel", "sentinel | equivalent")
 	flag.Parse()
@@ -73,31 +80,47 @@ func main() {
 		fail(2, "parse error: %v", err)
 	}
 
-	var freeMatches []*ast.FuncDecl
-	methodMatch := false
+	// Collect BOTH free functions and methods named *fn. The proof lane only ever
+	// targets a method whose name is UNIQUE in its package (the analyzer's
+	// uniqueGoPackageSymbol refuses cross-file collisions before an edge is minted);
+	// this file-scoped count is the in-file backstop, so free+method or two-method
+	// collisions fail(3) as ambiguous — never a mislabeled mutation. A lone decl
+	// (free OR method) is mutated identically via the receiver-agnostic sentinel.
+	var matches []*ast.FuncDecl
 	for _, decl := range astFile.Decls {
 		fd, ok := decl.(*ast.FuncDecl)
 		if !ok || fd.Name == nil || fd.Name.Name != *fn {
 			continue
 		}
-		if fd.Recv != nil { // method -> out of scope for G-1
-			methodMatch = true
+		// Refuse generic receivers (r T[U]) — receiver base type is not a bare Ident.
+		if fd.Recv != nil && recvBaseIdent(fd) == nil {
 			continue
 		}
-		freeMatches = append(freeMatches, fd)
+		// Receiver-exact selection: when --recv is set, only a method on that base
+		// receiver type matches — a free function or another receiver never can, so
+		// a receiver-qualified target can never mutate the wrong declaration.
+		if *recv != "" {
+			if fd.Recv == nil {
+				continue
+			}
+			if id := recvBaseIdent(fd); id == nil || id.Name != *recv {
+				continue
+			}
+		}
+		matches = append(matches, fd)
 	}
 
-	if len(freeMatches) > 1 {
-		fail(3, "ambiguous: %d free functions named %q", len(freeMatches), *fn)
+	if len(matches) > 1 {
+		fail(3, "ambiguous: %d declarations named %q (free and/or methods)", len(matches), *fn)
 	}
-	if len(freeMatches) == 0 {
-		if methodMatch {
-			fail(5, "out of scope: %q is a method (G-2); G-1 handles free functions only", *fn)
+	if len(matches) == 0 {
+		if *recv != "" {
+			fail(4, "not found: no method named %q on receiver %q", *fn, *recv)
 		}
-		fail(4, "not found: no free function named %q", *fn)
+		fail(4, "not found: no free function or method named %q", *fn)
 	}
 
-	target := freeMatches[0]
+	target := matches[0]
 	results := target.Type.Results
 	if results == nil || len(results.List) == 0 {
 		fail(6, "not mutable: %q has no return values; no signature-derived sentinel is possible", *fn)
@@ -160,6 +183,22 @@ func blankUnusedImports(f *ast.File) {
 	}
 }
 
+// recvBaseIdent returns the receiver type's base identifier for a method decl
+// (unwrapping a pointer receiver `*T` to `T`), or nil for a generic/unsupported
+// receiver. Used only to refuse generic receivers; value-vs-pointer is irrelevant
+// to body mutation (Go auto-(de)refs at the call site).
+func recvBaseIdent(fd *ast.FuncDecl) *ast.Ident {
+	if fd.Recv == nil || len(fd.Recv.List) != 1 {
+		return nil
+	}
+	t := fd.Recv.List[0].Type
+	if star, ok := t.(*ast.StarExpr); ok {
+		t = star.X
+	}
+	id, _ := t.(*ast.Ident)
+	return id
+}
+
 // sentinelBody builds `{ return <zero>, <zero>, ... }` matching the function's
 // result signature so the mutant COMPILES. Zero values are type-derived and
 // deliberately wrong for any function whose real return is non-zero; when a

package/scripts/spikes/java-dynamic-proof-spike.mjs

@@ -21,9 +21,11 @@
 // classify as `unrunnable`, never `proven`. An equivalent-value mutation survives ->
 // `associated_survived`. An ambiguous method name is refused -> `unrunnable`.
 //
-// This is a spike harness only: it writes no graph edges or product artifacts and
-// is NOT wired into autoProve / cert / RTM / the mint path. Pin: Maven + Surefire +
-// JUnit 5 (the Spring Boot default). Gradle / JUnit4 are later parsers.
+// PRODUCT-WIRED: `opro` routes Java dynamic proof through this script (operations.ts
+// dynamicProofSpikePathFor("java")). The script itself writes no graph edges or
+// product artifacts — it emits a JSON verdict; the orchestrator is the sole
+// interpreter and the only place proof is minted. Pin: Maven + Surefire + JUnit 5
+// (the Spring Boot default). Gradle / JUnit4 are later parsers.
 import { spawnSync } from "node:child_process";
 import { cpSync, existsSync, lstatSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -40,7 +42,7 @@ function usage() {
     "",
     "Runs ONE Surefire target test on a byte-copy of a single-module Maven + JUnit 5 project, mutates the target method body via a signature-derived sentinel, reruns the SAME test, and classifies from the structured surefire report.",
     "J-1 scope: SIMPLEST SHAPE ONLY — a concrete non-void return, a single top-level return, no generics, no overloads. Equivalent-value mutations survive (associated_survived). Ambiguous names are refused (unrunnable).",
-    "This is a spike harness only; it does not write graph edges or product artifacts and is not wired into prove/RTM/mint."
+    "Product wiring: opro prove/auto-prove invokes this script for Java targets; it writes no graph edges or product artifacts itself — the caller interprets the JSON verdict."
   ].join("\n");
 }
 

package/scripts/spikes/java-mutate.mjs

@@ -5,8 +5,9 @@
 // by exact name via tree-sitter Java (the SAME grammar the static layer already
 // uses — tree-sitter-wasms + web-tree-sitter, no new dependency) and replaces its
 // BODY with a signature-derived, type-compatible sentinel by splicing the body
-// block's byte range. It is a spike helper only: it writes no product artifacts and
-// is not wired into prove / RTM / mint.
+// block's byte range. Invoked by java-dynamic-proof-spike.mjs (the product Java
+// proof path); it writes ONLY the mutated file inside the sandbox copy — no graph
+// or product artifacts.
 //
 // J-1 scope is the SIMPLEST SHAPE ONLY: a concrete non-void, non-type-variable
 // return type, EXACTLY one top-level `return <expr>;` (no nested return in an