Automated Capability Documentation

Deterministic, zero-token refactoring capabilities extracted directly from compiler AST implementations and executable test archives (txtar).

View the semedit repository on GitHub

Cross-Language Edit & Refactoring Capability Matrix

Per-Language Operation Contracts

Contracts distinguish exact request variants, prerequisites, capabilities, and scoped guarantees. Supported means the operation can meet those guarantees when its other prerequisites hold; it does not promise a clean project. Conditional cases require the named analysis, normalization, or reporting condition. Unknown cases make no promise.

Fault bits 0 through 5 represent target-file syntax/type errors, syntax/type errors in another file of the same package, and syntax/type errors in another package. Each 64-bit support mask has one bit per exact fault combination: uint64(1) << faults. Mixed faults use that exact bit; individual support implies no combined support.

Go (Golang)

Rust

Java

Scala

Haskell

Kotlin

Bash

Makefile

Language Constraints & Capability Rules

Go (Golang) Engine Constraints

• Unsupported Modifiers Rejection: Go lacks ‘protected’ and ‘package-private’ scopes. The engine rejects these modifiers with ErrUnsupportedModifier.
• Casing & Visibility Invariant: Identifier capitalization governs visibility. Specifying ‘public’ for a lowercase symbol or ‘private’ for an uppercase symbol returns VisibilityMismatchError.
• Strict Public-Precedes-Private Ordering: All public declarations precede private declarations within generated or updated source files.
• Receiver Method Clustering: Methods sharing a common receiver type cluster near each other while maintaining public vs private partitioning.
• Declaration Block Merging: Constants and variables automatically merge into existing ‘const (…)’ or ‘var (…)’ blocks instead of creating duplicate blocks.

Rust Engine Constraints

• Trusted Explicit Workspace: Lookup requires a selected .rs file, a deterministic Cargo root, explicit workspace trust, and a preinstalled rust-analyzer; Cargo is never invoked.
• Hierarchical Document Symbols: Only exact hierarchical document symbols and associated items are resolved; macros, generated symbols, locals, ambiguous trait methods, and multiple impl resolution are not promised.

Java Engine Constraints

• Trusted Explicit Workspace: Java edits and JDT LS reads require an explicit or unambiguous workspace root, explicit workspace trust, a preinstalled JDT LS distribution, and Java 21 or newer; JDT LS operations never invoke build tools. Bounded Maven process actions are exposed separately by the central operation registry.
• Hierarchical Document Symbols: Hierarchical package, type, field, method, and constructor symbols are resolved; overloaded methods accept signature-qualified selectors. Locals, generated symbols, and malformed-source fallback are not promised.

Scala Engine Constraints

• Trusted Explicit Tools: Lookup requires a selected .scala file, an explicit workspace root for project markers, explicit workspace trust, a pinned preinstalled Metals distribution, and recorded Java 21 or newer; no build tool is invoked.
• Hierarchical Document Symbols: Only exact hierarchical classes, objects, traits, enums, methods, fields, and nested types are resolved; overload signatures, givens, extensions, package objects, generated symbols, and cross-file SemanticDB search are not promised.

Haskell Engine Constraints

• Explicit Standalone Trust: Lookup requires –haskell-standalone (or standalone_haskell=true), a selected .hs file, explicit workspace trust, preinstalled GHC, and a matching preinstalled haskell-language-server-wrapper; hie.yaml, stack.yaml, cabal.project, *.cabal, and package.yaml project markers are rejected.
• Hierarchical Document Symbols: Only module, top-level values, types, classes, constructors, fields, and instances returned hierarchically by HLS are resolved; locals, pattern synonyms, duplicate record fields, reexports, generated or Template Haskell symbols, and malformed-source fallback are not promised.

Kotlin Engine Constraints

• Trusted Server: A selected .kt or .kts file and request-scoped workspace trust are required before the preinstalled fwcd/kotlin-language-server is resolved or launched. Upstream may execute project classpath scripts or Maven/Gradle while resolving dependencies.
• Selected File Diagnostics: Verification requires a matching publishDiagnostics notification for the selected isolated file; no report before timeout is an error, not a clean result. Formatting and import modes are rejected.

Bash Engine Constraints

• Selected File: Only .sh and .bash files are accepted. The server runs in a source-only scratch workspace after request-scoped workspace trust.
• Optional Shell Tools: bash-language-server may invoke an installed ShellCheck against the copied selected source; the backend does not execute the shell script.
• Diagnostics Receipt: Verification requires an explicit matching publishDiagnostics report. Silence and malformed reports are errors.

Makefile Engine Constraints

• Selected File: Only Makefile, makefile, GNUmakefile, and .mk files are accepted. make-ls runs in an isolated source workspace after request-scoped trust.
• Include Reads: make-ls resolves includes; absolute paths and relative paths traversing outside the copied source may read files after trust is granted.

Placement Qualifiers

Executable Test Workflows

Active, compiler-verified regression tests in testdata/scripts/*.txtar provide every scenario below.

Test build-level dependency validation without network access

Source: add_build_dependency.txtar · Download raw file

Execute: exec semedit add-build-dependency

CLI invocation

$ exec semedit add-build-dependency

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: add-build-dependency: param “package” is required: invalid operation parameters

Execute: exec semedit add-build-dependency –package ""

CLI invocation

$ exec semedit add-build-dependency --package ""

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: malformed module path

Add a local replacement module to go.mod without network access.

Source: add_build_dependency_go.txtar · Download raw file

Execute: semedit add-build-dependency –package example.com/localdep

CLI invocation

$ semedit add-build-dependency --package example.com/localdep

Equivalent MCP tool call (semantic_add_build_dependency)

{
  "package": "example.com/localdep"
}

Assert: Successfully added dependency example.com/localdep and tidied go.mod.

Unified AST transformation diff

  module example.com/test
  
  go 1.23
  
  replace example.com/localdep => ./localdep
  
+ require example.com/localdep v0.0.0-00010101000000-000000000000

Expected output state (go.mod)

module example.com/test

go 1.23

replace example.com/localdep => ./localdep

require example.com/localdep v0.0.0-00010101000000-000000000000

Add a versioned dependency to a Maven parent and a versionless child entry.

Source: add_build_dependency_java_reactor.txtar · Download raw file

Execute: semedit add-build-dependency –language java –trust-workspace –dependency org.example:codec:2.1 –file core

CLI invocation

$ semedit add-build-dependency --language java --trust-workspace --dependency org.example:codec:2.1 --file core

Equivalent MCP tool call (semantic_add_build_dependency)

{
  "dependency": "org.example:codec:2.1",
  "file": "core",
  "language": "java",
  "trust_workspace": true
}

Assert: Successfully added Maven dependency org.example:codec:2.1 to 2 POM

Unified AST transformation diff (core/pom.xml)

  <project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    <parent>
      <groupId>org.example</groupId>
      <artifactId>reactor</artifactId>
      <version>1</version>
    </parent>
    <artifactId>core</artifactId>
+   <dependencies>
+     <dependency>
        <groupId>org.example</groupId>
+       <artifactId>codec</artifactId>
+     </dependency>
+   </dependencies>
  </project>

Expected output state (core/pom.xml)

<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.example</groupId>
    <artifactId>reactor</artifactId>
    <version>1</version>
  </parent>
  <artifactId>core</artifactId>
  <dependencies>
    <dependency>
      <groupId>org.example</groupId>
      <artifactId>codec</artifactId>
    </dependency>
  </dependencies>
</project>

Unified AST transformation diff (pom.xml)

  <project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.example</groupId>
    <artifactId>reactor</artifactId>
    <version>1</version>
    <packaging>pom</packaging>
    <modules><module>core</module></modules>
    <dependencyManagement>
      <dependencies>
        <!-- Keep this comment in place. -->
+       <dependency>
          <groupId>org.example</groupId>
+         <artifactId>codec</artifactId>
+         <version>2.1</version>
+       </dependency>
      </dependencies>
    </dependencyManagement>
  </project>

Expected output state (pom.xml)

<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>reactor</artifactId>
  <version>1</version>
  <packaging>pom</packaging>
  <modules><module>core</module></modules>
  <dependencyManagement>
    <dependencies>
      <!-- Keep this comment in place. -->
      <dependency>
        <groupId>org.example</groupId>
        <artifactId>codec</artifactId>
        <version>2.1</version>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>

Test assertion-mode: dry-run previews without writing, relax rewrites with trust

Source: assertion_mode.txtar · Download raw file

Execute: semedit assertion-mode –file api/api_test.go –mode relax –dry-run

CLI invocation

$ semedit assertion-mode --file api/api_test.go --mode relax --dry-run

Equivalent MCP tool call (semantic_assertion_mode)

{
  "dry_run": true,
  "file": "api/api_test.go",
  "mode": "relax"
}

Assert: 1 swapped

Assert: dry run

Execute: semedit assertion-mode –file api/api_test.go –mode relax –trust-workspace

CLI invocation

$ semedit assertion-mode --file api/api_test.go --mode relax --trust-workspace

Equivalent MCP tool call (semantic_assertion_mode)

{
  "file": "api/api_test.go",
  "mode": "relax",
  "trust_workspace": true
}

Assert: wrote api/api_test.go

Execute: semedit assertion-mode –file api/api_test.go –mode relax –trust-workspace

CLI invocation

$ semedit assertion-mode --file api/api_test.go --mode relax --trust-workspace

Equivalent MCP tool call (semantic_assertion_mode)

{
  "file": "api/api_test.go",
  "mode": "relax",
  "trust_workspace": true
}

Assert: No assertions changed in api/api_test.go.

Execute: exec semedit assertion-mode –file api/api_test.go –mode relax

CLI invocation

$ exec semedit assertion-mode --file api/api_test.go --mode relax

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: workspace trust required

Execute: exec semedit assertion-mode –file api/api_test.go –mode sideways

CLI invocation

$ exec semedit assertion-mode --file api/api_test.go --mode sideways

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: must be one of

Unified AST transformation diff (api/api_test.go)

  package api
  
  import "testing"
  
  func TestPing(t *testing.T) {
  	if err := Ping(); err != nil {
  		t.Fatalf("Ping failed: %v", err)
  	}
  	if Probe() != "out" {
  		t.Errorf("Probe wrong")
  	}
  }

Expected output state (api/api_test.go)

package api

import "testing"

func TestPing(t *testing.T) {
	if err := Ping(); err != nil {
		t.Fatalf("Ping failed: %v", err)
	}
	if Probe() != "out" {
		t.Errorf("Probe wrong")
	}
}

Unified AST transformation diff (api/api_test.go)

- 		t.Fatalf("Ping failed: %v", err)
  package api
  
  import "testing"
  
  func TestPing(t *testing.T) {
  	if err := Ping(); err != nil {
+ 		t.Errorf("Ping failed: %v", err)
  	}
  	if Probe() != "out" {
  		t.Errorf("Probe wrong")
  	}
  }

Expected output state (api/api_test.go)

package api

import "testing"

func TestPing(t *testing.T) {
	if err := Ping(); err != nil {
		t.Errorf("Ping failed: %v", err)
	}
	if Probe() != "out" {
		t.Errorf("Probe wrong")
	}
}

Reject misspelled batch arguments with indexed suggestions before any workspace operation.

Source: batch_params_shape.txtar · Download raw file

Execute: semedit mcp

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: isError":true

Assert: edit 0 params

Assert: semantic_rename

Assert: unknown parameter

Assert: symobl

Assert: Did you mean

Assert: symbol

Assert: Required parameters

Fail-fast batch execution across multiple files

Source: batch_partial.txtar · Download raw file

1. Execute batch with valid first edit and invalid second edit

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: isError":true

Assert: NonExistentSymbol

Unified AST transformation diff (file1.go)

- 	return "pending"
  package main
  
  func StepOne() string {
+ 	return "completed"
  }

Expected output state (file1.go)

package main

func StepOne() string {
	return "completed"
}

Unified AST transformation diff (file2.go)

  package main
  
  func StepTwo() string {
  	return "untouched"
  }

Expected output state (file2.go)

package main

func StepTwo() string {
	return "untouched"
}

The CLI appends one typed parameter across source and test callers, preserves unrelated bytes, and refuses unsafe bindings without writes.

Source: change_signature_go.txtar · Download raw file

Execute: semedit change-signature –file service.go –symbol transform –parameters ‘[{“source_index”:0,“parameter”:{“name”:“id”,“type”:“int”}},{“parameter”:{“name”:“ctx”,“type”:"*int"},“argument”:“nil”}]’

CLI invocation

$ semedit change-signature --file service.go --symbol transform --parameters '[{"source_index":0,"parameter":{"name":"id","type":"int"}},{"parameter":{"name":"ctx","type":"*int"},"argument":"nil"}]'

Equivalent MCP tool call (semantic_change_signature)

{
  "file": "service.go",
  "parameters": "[{\"source_index\":0,\"parameter\":{\"name\":\"id\",\"type\":\"int\"}},{\"parameter\":{\"name\":\"ctx\",\"type\":\"*int\"},\"argument\":\"nil\"}]",
  "symbol": "transform"
}

Assert: Updated the function signature and every proven direct caller.

Execute: semedit change-signature –file service.go –symbol transform –parameters ‘[{“source_index”:0,“parameter”:{“name”:“id”,“type”:“int”}},{“source_index”:1,“parameter”:{“name”:“ctx”,“type”:"*int"}}]’

CLI invocation

$ semedit change-signature --file service.go --symbol transform --parameters '[{"source_index":0,"parameter":{"name":"id","type":"int"}},{"source_index":1,"parameter":{"name":"ctx","type":"*int"}}]'

Equivalent MCP tool call (semantic_change_signature)

{
  "file": "service.go",
  "parameters": "[{\"source_index\":0,\"parameter\":{\"name\":\"id\",\"type\":\"int\"}},{\"source_index\":1,\"parameter\":{\"name\":\"ctx\",\"type\":\"*int\"}}]",
  "symbol": "transform"
}

Assert: already present

Execute: semedit change-signature –file service.go –symbol noop –parameters ‘[]’

CLI invocation

$ semedit change-signature --file service.go --symbol noop --parameters '[]'

Equivalent MCP tool call (semantic_change_signature)

{
  "file": "service.go",
  "parameters": "[]",
  "symbol": "noop"
}

Assert: already present

Execute: exec semedit change-signature –file service.go –symbol indirect –parameters ‘[{“source_index”:0,“parameter”:{“name”:“id”,“type”:“int”}},{“parameter”:{“name”:“enabled”,“type”:“bool”},“argument”:“true”}]’

CLI invocation

$ exec semedit change-signature --file service.go --symbol indirect --parameters '[{"source_index":0,"parameter":{"name":"id","type":"int"}},{"parameter":{"name":"enabled","type":"bool"},"argument":"true"}]'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: function values and indirect callers are unsupported

Execute: exec semedit change-signature –file service.go –symbol usesGlobal –parameters ‘[{“source_index”:0,“parameter”:{“name”:“id”,“type”:“int”}},{“parameter”:{“name”:“globalValue”,“type”:“int”},“argument”:“0”}]’

CLI invocation

$ exec semedit change-signature --file service.go --symbol usesGlobal --parameters '[{"source_index":0,"parameter":{"name":"id","type":"int"}},{"parameter":{"name":"globalValue","type":"int"},"argument":"0"}]'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: conflicts with an existing body binding

Java change-signature delegates the ordered signature and caller edits to JDT LS.

Source: change_signature_java.txtar · Download raw file

Execute: semedit change-signature –language java –trust-workspace –java-bin $SEMEDIT_TEST_JAVA –jdtls-home tools/jdtls –file src/Service.java –symbol ‘Service.send(int)’ –parameters ‘[{“source_index”:0,“parameter”:{“name”:“identifier”,“type”:“long”}},{“parameter”:{“name”:“enabled”,“type”:“boolean”},“argument”:“true”}]’

CLI invocation

$ semedit change-signature --language java --trust-workspace --java-bin $SEMEDIT_TEST_JAVA --jdtls-home tools/jdtls --file src/Service.java --symbol 'Service.send(int)' --parameters '[{"source_index":0,"parameter":{"name":"identifier","type":"long"}},{"parameter":{"name":"enabled","type":"boolean"},"argument":"true"}]'

Equivalent MCP tool call (semantic_change_signature)

{
  "file": "src/Service.java",
  "java_bin": "$SEMEDIT_TEST_JAVA",
  "jdtls_home": "tools/jdtls",
  "language": "java",
  "parameters": "[{\"source_index\":0,\"parameter\":{\"name\":\"identifier\",\"type\":\"long\"}},{\"parameter\":{\"name\":\"enabled\",\"type\":\"boolean\"},\"argument\":\"true\"}]",
  "symbol": "Service.send(int)",
  "trust_workspace": true
}

Unified AST transformation diff (src/Caller.java)

-     service.send(7);
  package sample;
  class Caller {
    void run(Service service) {
+     service.send(7, true);
    }
  }

Expected output state (src/Caller.java)

package sample;
class Caller {
  void run(Service service) {
    service.send(7, true);
  }
}

Unified AST transformation diff (src/Service.java)

-   void send(int id) {
-     System.out.println(id);
  package sample;
  class Service {
+   void send(long identifier, boolean enabled) {
+     System.out.println(identifier);
    }
  }

Expected output state (src/Service.java)

package sample;
class Service {
  void send(long identifier, boolean enabled) {
    System.out.println(identifier);
  }
}

The CLI appends parameters and call arguments after existing multiline trailing commas without creating invalid comma layouts.

Source: change_signature_trailing_comma_go.txtar · Download raw file

Execute: semedit change-signature –file service.go –symbol transform –parameters ‘[{“source_index”:0,“parameter”:{“name”:“id”,“type”:“int”}},{“parameter”:{“name”:“enabled”,“type”:“bool”},“argument”:“true”}]’

CLI invocation

$ semedit change-signature --file service.go --symbol transform --parameters '[{"source_index":0,"parameter":{"name":"id","type":"int"}},{"parameter":{"name":"enabled","type":"bool"},"argument":"true"}]'

Equivalent MCP tool call (semantic_change_signature)

{
  "file": "service.go",
  "parameters": "[{\"source_index\":0,\"parameter\":{\"name\":\"id\",\"type\":\"int\"}},{\"parameter\":{\"name\":\"enabled\",\"type\":\"bool\"},\"argument\":\"true\"}]",
  "symbol": "transform"
}

Structural insertion keeps anchored comments attached to their code

Source: comment_anchors.txtar · Download raw file

Execute: semedit insert –file api/anchors.go –placement before_symbol –target Keep –source ‘func AddedBefore() {}’

CLI invocation

$ semedit insert --file api/anchors.go --placement before_symbol --target Keep --source 'func AddedBefore() {}'

Equivalent MCP tool call (semantic_insert_declaration)

{
  "file": "api/anchors.go",
  "placement": "before_symbol",
  "source": "func AddedBefore() {}",
  "target_symbol": "Keep"
}

Execute: semedit insert –file api/anchors.go –placement after_symbol –target Target –source ‘func AddedAfter() {}’

CLI invocation

$ semedit insert --file api/anchors.go --placement after_symbol --target Target --source 'func AddedAfter() {}'

Equivalent MCP tool call (semantic_insert_declaration)

{
  "file": "api/anchors.go",
  "placement": "after_symbol",
  "source": "func AddedAfter() {}",
  "target_symbol": "Target"
}

Execute: semedit insert-case –file api/handler.go –in-function Handle –discriminator value –placement before_default –case ‘case “added”: return “added”’

CLI invocation

$ semedit insert-case --file api/handler.go --in-function Handle --discriminator value --placement before_default --case 'case "added": return "added"'

Equivalent MCP tool call (semantic_insert_case)

{
  "case": "case \"added\": return \"added\"",
  "discriminator": "value",
  "file": "api/handler.go",
  "in_function": "Handle",
  "placement": "before_default"
}

Unified AST transformation diff (api/anchors.go)

  package api
  
+ func AddedBefore() {}
  
  // Keep documentation on Keep.
  func Keep() {}
  
  func Target() {} // Keep this trailing comment.
  
+ func AddedAfter() {}
  
  func Last() {}

Expected output state (api/anchors.go)

package api

func AddedBefore() {}

// Keep documentation on Keep.
func Keep() {}

func Target() {} // Keep this trailing comment.

func AddedAfter() {}

func Last() {}

Unified AST transformation diff (api/handler.go)

  package api
  
  func Handle(value string) string {
  	switch value {
  	case "keep":
  		return "keep"
+ 	case "added":
+ 		return "added"
  	// Keep this comment on the default case.
  	default:
  		return "default"
  	}
  }

Expected output state (api/handler.go)

package api

func Handle(value string) string {
	switch value {
	case "keep":
		return "keep"
	case "added":
		return "added"
	// Keep this comment on the default case.
	default:
		return "default"
	}
}

Specific declaration kinds must parse comments while rejecting wrong or multiple declaration forms before writing.

Source: commented_declaration_insert.txtar · Download raw file

Execute: semedit insert-construct –file request.go –kind var –placement after_symbol –target ErrRequest –group standalone –source -

CLI invocation

$ semedit insert-construct --file request.go --kind var --placement after_symbol --target ErrRequest --group standalone --source -

Equivalent MCP tool call (semantic_insert_construct)

{
  "file": "request.go",
  "group": "standalone",
  "kind": "var",
  "placement": "after_symbol",
  "source": "-",
  "target_symbol": "ErrRequest"
}

Assert: Successfully inserted var construct

Execute: semedit insert-construct –file request.go –kind const –placement after_symbol –target ErrInvalidRequest –group standalone –source -

CLI invocation

$ semedit insert-construct --file request.go --kind const --placement after_symbol --target ErrInvalidRequest --group standalone --source -

Equivalent MCP tool call (semantic_insert_construct)

{
  "file": "request.go",
  "group": "standalone",
  "kind": "const",
  "placement": "after_symbol",
  "source": "-",
  "target_symbol": "ErrInvalidRequest"
}

Assert: Successfully inserted const construct

Execute: semedit insert-construct –file request.go –kind type –placement after_symbol –target Request –source -

CLI invocation

$ semedit insert-construct --file request.go --kind type --placement after_symbol --target Request --source -

Equivalent MCP tool call (semantic_insert_construct)

{
  "file": "request.go",
  "kind": "type",
  "placement": "after_symbol",
  "source": "-",
  "target_symbol": "Request"
}

Assert: Successfully inserted type construct

Execute: exec semedit insert-construct –file request.go –kind var –source -

CLI invocation

$ exec semedit insert-construct --file request.go --kind var --source -

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: var insertion requires a var declaration

Execute: exec semedit insert-construct –file request.go –kind var –source -

CLI invocation

$ exec semedit insert-construct --file request.go --kind var --source -

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: var insertion requires exactly one var declaration

Structural type and function insertions reject duplicates and unsupported overwrites without changing source.

Source: construct_collisions.txtar · Download raw file

Execute: exec semedit insert-construct –file api/model.go –kind type –source ’type Config struct { Port int }’

CLI invocation

$ exec semedit insert-construct --file api/model.go --kind type --source 'type Config struct { Port int }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: Config.*already exists

Execute: exec semedit insert-construct –file api/model.go –kind type –overwrite –source ’type Config struct { Port int }’

CLI invocation

$ exec semedit insert-construct --file api/model.go --kind type --overwrite --source 'type Config struct { Port int }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: unknown flag.*overwrite

Execute: exec semedit insert-construct –file api/model.go –kind function –source ‘func Load() string { return “new” }’

CLI invocation

$ exec semedit insert-construct --file api/model.go --kind function --source 'func Load() string { return "new" }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: Load.*already exists

Execute: exec semedit insert-construct –file api/model.go –kind method –source ‘func (w *Widget) Name() string { return “new” }’

CLI invocation

$ exec semedit insert-construct --file api/model.go --kind method --source 'func (w *Widget) Name() string { return "new" }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: method Widget.Name already exists

Whole named declarations replace by symbol without an enclosing function.

Source: construct_declaration_replacements.txtar · Download raw file

Execute: semedit replace-construct –file declarations.go –kind function –symbol Convert –source ‘func Convert(text string) string { return text }’

CLI invocation

$ semedit replace-construct --file declarations.go --kind function --symbol Convert --source 'func Convert(text string) string { return text }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "declarations.go",
  "kind": "function",
  "source": "func Convert(text string) string { return text }",
  "symbol": "Convert"
}

Execute: semedit replace-construct –file declarations.go –kind type –symbol Config –source ’type Config struct { Port int }’

CLI invocation

$ semedit replace-construct --file declarations.go --kind type --symbol Config --source 'type Config struct { Port int }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "declarations.go",
  "kind": "type",
  "source": "type Config struct { Port int }",
  "symbol": "Config"
}

Execute: semedit replace-construct –file declarations.go –kind const –symbol Limit –source ‘const Limit = 20’

CLI invocation

$ semedit replace-construct --file declarations.go --kind const --symbol Limit --source 'const Limit = 20'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "declarations.go",
  "kind": "const",
  "source": "const Limit = 20",
  "symbol": "Limit"
}

Execute: semedit replace-construct –file declarations.go –kind var –symbol Revision –source ‘var Revision = 2’

CLI invocation

$ semedit replace-construct --file declarations.go --kind var --symbol Revision --source 'var Revision = 2'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "declarations.go",
  "kind": "var",
  "source": "var Revision = 2",
  "symbol": "Revision"
}

Execute: semedit replace-construct –file declarations.go –kind method –symbol dnsBuilder.Build –source ‘func (b *dnsBuilder) Build(target string, secure bool) (string, error) { return target, nil }’

CLI invocation

$ semedit replace-construct --file declarations.go --kind method --symbol dnsBuilder.Build --source 'func (b *dnsBuilder) Build(target string, secure bool) (string, error) { return target, nil }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "declarations.go",
  "kind": "method",
  "source": "func (b *dnsBuilder) Build(target string, secure bool) (string, error) { return target, nil }",
  "symbol": "dnsBuilder.Build"
}

Execute: semedit replace-construct –file declarations.go –kind method –symbol ‘(*dnsBuilder).Build’ –source ‘func (b *dnsBuilder) Build(target string, secure bool) (string, error) { if secure { return target, nil }; return “”, nil }’

CLI invocation

$ semedit replace-construct --file declarations.go --kind method --symbol '(*dnsBuilder).Build' --source 'func (b *dnsBuilder) Build(target string, secure bool) (string, error) { if secure { return target, nil }; return "", nil }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "declarations.go",
  "kind": "method",
  "source": "func (b *dnsBuilder) Build(target string, secure bool) (string, error) { if secure { return target, nil }; return \"\", nil }",
  "symbol": "(*dnsBuilder).Build"
}

Execute: exec semedit replace-construct –file declarations.go –kind type –symbol Config –source ’type Other struct { Host string }’

CLI invocation

$ exec semedit replace-construct --file declarations.go --kind type --symbol Config --source 'type Other struct { Host string }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: name|identity|Config

Execute: exec semedit replace-construct –file declarations.go –kind method –symbol dnsBuilder.Build –source ‘func (b *otherBuilder) Build(target string, secure bool) (string, error) { return target, nil }’

CLI invocation

$ exec semedit replace-construct --file declarations.go --kind method --symbol dnsBuilder.Build --source 'func (b *otherBuilder) Build(target string, secure bool) (string, error) { return target, nil }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: receiver.*dnsBuilder

Execute: exec semedit replace-construct –file declarations.go –kind method –symbol dnsBuilder.Build –source ‘func (b *dnsBuilder) Resolve(target string, secure bool) (string, error) { return target, nil }’

CLI invocation

$ exec semedit replace-construct --file declarations.go --kind method --symbol dnsBuilder.Build --source 'func (b *dnsBuilder) Resolve(target string, secure bool) (string, error) { return target, nil }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: preserve.*method.*dnsBuilder.Build

Execute: exec semedit replace-construct –file declarations.go –kind method –symbol dnsBuilder.Build –source ‘func (b dnsBuilder) Build(target string, secure bool) (string, error) { return target, nil }’

CLI invocation

$ exec semedit replace-construct --file declarations.go --kind method --symbol dnsBuilder.Build --source 'func (b dnsBuilder) Build(target string, secure bool) (string, error) { return target, nil }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: receiver syntax

Generic construct insertion adds one field and refuses an existing field name.

Source: construct_field_insertion.txtar · Download raw file

Execute: semedit insert-construct –file model.go –kind field –in-type config –source ‘Port int’ –placement type_end

CLI invocation

$ semedit insert-construct --file model.go --kind field --in-type config --source 'Port int' --placement type_end

Equivalent MCP tool call (semantic_insert_construct)

{
  "file": "model.go",
  "in_type": "config",
  "kind": "field",
  "placement": "type_end",
  "source": "Port int"
}

Assert: Successfully inserted field construct

Execute: exec semedit insert-construct –file model.go –kind field –in-type config –source ‘Port string’ –placement type_end

CLI invocation

$ exec semedit insert-construct --file model.go --kind field --in-type config --source 'Port string' --placement type_end

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: already exists|collision

Execute: exec semedit insert-construct –file model.go –kind field –in-type Config –source ‘Port int’ –placement type_end

CLI invocation

$ exec semedit insert-construct --file model.go --kind field --in-type Config --source 'Port int' --placement type_end

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: cannot prove positional-literal compatibility for exported owner

Execute: exec semedit insert-construct –file model.go –kind field –in-type config –source ‘Hidden int’ –access private

CLI invocation

$ exec semedit insert-construct --file model.go --kind field --in-type config --source 'Hidden int' --access private

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: private|unexported

Execute: semedit insert-construct –file model.go –kind field –in-type config –source ‘Ready bool’ –placement type_start –access public

CLI invocation

$ semedit insert-construct --file model.go --kind field --in-type config --source 'Ready bool' --placement type_start --access public

Equivalent MCP tool call (semantic_insert_construct)

{
  "access_modifier": "public",
  "file": "model.go",
  "in_type": "config",
  "kind": "field",
  "placement": "type_start",
  "source": "Ready bool"
}

Unified AST transformation diff

  package model
  
  type config struct {
+ 	Ready bool
  	Host string
+ 	Port int
  }
  type Config struct{}

Expected output state (model.go)

package model

type config struct {
	Ready bool
	Host string
	Port int
}
type Config struct{}

Function replacement accepts receiver-bearing source while preserving the selected method and receiver syntax.

Source: construct_function_method_compatibility.txtar · Download raw file

Execute: semedit replace-construct –file request.go –kind function –symbol Request.Validate –source ‘func (r *Request) Validate() string { return “qualified” }’

CLI invocation

$ semedit replace-construct --file request.go --kind function --symbol Request.Validate --source 'func (r *Request) Validate() string { return "qualified" }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "request.go",
  "kind": "function",
  "source": "func (r *Request) Validate() string { return \"qualified\" }",
  "symbol": "Request.Validate"
}

Execute: semedit replace-construct –file request.go –kind function –symbol Validate –source ‘func (r *Request) Validate() string { return “unqualified” }’

CLI invocation

$ semedit replace-construct --file request.go --kind function --symbol Validate --source 'func (r *Request) Validate() string { return "unqualified" }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "request.go",
  "kind": "function",
  "source": "func (r *Request) Validate() string { return \"unqualified\" }",
  "symbol": "Validate"
}

Execute: exec semedit replace-construct –file request.go –kind function –symbol Request.Validate –source ‘func (r *Other) Validate() string { return “wrong” }’

CLI invocation

$ exec semedit replace-construct --file request.go --kind function --symbol Request.Validate --source 'func (r *Other) Validate() string { return "wrong" }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: receiver.*Request

Execute: exec semedit replace-construct –file request.go –kind function –symbol Request.Validate –source ‘func (r Request) Validate() string { return “value” }’

CLI invocation

$ exec semedit replace-construct --file request.go --kind function --symbol Request.Validate --source 'func (r Request) Validate() string { return "value" }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: receiver syntax

Execute: exec semedit replace-construct –file request.go –kind function –symbol Request.Validate –source ‘func Validate() string { return “lost receiver” }’

CLI invocation

$ exec semedit replace-construct --file request.go --kind function --symbol Request.Validate --source 'func Validate() string { return "lost receiver" }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: receiver.*Request

Execute: exec semedit replace-construct –file request.go –kind method –symbol Validate –source ‘func (r *Request) Validate() string { return “unqualified method” }’

CLI invocation

$ exec semedit replace-construct --file request.go --kind method --symbol Validate --source 'func (r *Request) Validate() string { return "unqualified method" }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: receiver

Execute: exec semedit replace-construct –file request.go –kind method –symbol Request.Validate –source ‘func Validate() string { return “lost receiver” }’

CLI invocation

$ exec semedit replace-construct --file request.go --kind method --symbol Request.Validate --source 'func Validate() string { return "lost receiver" }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: preserve.*method

Execute: semedit replace-construct –file request.go –kind method –symbol ‘(*Request).Validate’ –source ‘func (r *Request) Validate() string { return “method” }’

CLI invocation

$ semedit replace-construct --file request.go --kind method --symbol '(*Request).Validate' --source 'func (r *Request) Validate() string { return "method" }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "request.go",
  "kind": "method",
  "source": "func (r *Request) Validate() string { return \"method\" }",
  "symbol": "(*Request).Validate"
}

Rejected insertion must preserve source through direct CLI and MCP batch publication.

Source: construct_import_preflight.txtar · Download raw file

Execute: exec semedit insert-construct –file audit/normalize.go –kind declaration –source ‘import “strings”’

CLI invocation

$ exec semedit insert-construct --file audit/normalize.go --kind declaration --source 'import "strings"'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: imports must appear before other declarations

Execute: exec semedit insert-construct –file audit/normalize.go –kind declaration –source ‘import “strings”’ –auto-organize-imports=false

CLI invocation

$ exec semedit insert-construct --file audit/normalize.go --kind declaration --source 'import "strings"' --auto-organize-imports=false

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: imports must appear before other declarations

Execute: semedit mcp

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: isError":true

Assert: imports must appear before other declarations

Execute: semedit mcp

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: isError":true

Assert: imports must appear before other declarations

Inspect a concrete candidate, copy its opaque selection revision and path into replacement, and verify the selected write.

Source: construct_inspection.txtar · Download raw file

Execute: semedit inspect-construct –file api/sample.go –in-function Check –kind if –discriminator ready

CLI invocation

$ semedit inspect-construct --file api/sample.go --in-function Check --kind if --discriminator ready

Equivalent MCP tool call (semantic_inspect_construct)

{
  "discriminator": "ready",
  "file": "api/sample.go",
  "in_function": "Check",
  "kind": "if"
}

Assert: construct_path": “0

Assert: expected_selection_revision”: “c950c86b12ee00875c2b2320365ce498ef2049cf70e5f8d69ae828cfd15a05d5

Execute: semedit replace-construct –file api/sample.go –in-function Check –kind if –discriminator ready –construct-path 0 –expected-selection-revision c950c86b12ee00875c2b2320365ce498ef2049cf70e5f8d69ae828cfd15a05d5 –source ‘if ready { use(2) }’

CLI invocation

$ semedit replace-construct --file api/sample.go --in-function Check --kind if --discriminator ready --construct-path 0 --expected-selection-revision c950c86b12ee00875c2b2320365ce498ef2049cf70e5f8d69ae828cfd15a05d5 --source 'if ready { use(2) }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "construct_path": "0",
  "discriminator": "ready",
  "expected_selection_revision": "c950c86b12ee00875c2b2320365ce498ef2049cf70e5f8d69ae828cfd15a05d5",
  "file": "api/sample.go",
  "in_function": "Check",
  "kind": "if",
  "source": "if ready { use(2) }"
}

Unified AST transformation diff

- 		use(1)
  package sample
  
  func Check() {
  	if ready {
+ 		use(2)
  	}
  }

Expected output state (api/sample.go)

package sample

func Check() {
	if ready {
		use(2)
	}
}

The batch read sees the prior buffered mutation; a stale optional guard returns that current choice and stops later edits.

Source: construct_inspection_mcp_batch.txtar · Download raw file

Execute: semedit inspect-construct –file api/sample.go –in-function Check –kind if –discriminator ready

CLI invocation

$ semedit inspect-construct --file api/sample.go --in-function Check --kind if --discriminator ready

Equivalent MCP tool call (semantic_inspect_construct)

{
  "discriminator": "ready",
  "file": "api/sample.go",
  "in_function": "Check",
  "kind": "if"
}

Assert: expected_selection_revision”: “c950c86b12ee00875c2b2320365ce498ef2049cf70e5f8d69ae828cfd15a05d5

Execute: semedit mcp

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: selection_revision_mismatch

Assert: application_state”:\s*“not_applied

Assert: file”:\s*“api/sample.go

Assert: in_function”:\s*“Check

Assert: kind”:\s*“if

Assert: discriminator”:\s*“ready

Assert: candidates

Assert: expected_selection_revision

Assert: construct_path

Assert: use(2)

Unified AST transformation diff

- 		use(1)
  package sample
  
  func Check() {
  	if ready {
+ 		use(2)
  	}
  }

Expected output state (api/sample.go)

package sample

func Check() {
	if ready {
		use(2)
	}
}

Retired insertion command names have no compatibility aliases.

Source: construct_old_commands_rejected.txtar · Download raw file

Execute: exec semedit insert-structure –help

CLI invocation

$ exec semedit insert-structure --help

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: unknown command

Execute: exec semedit insert-statement –help

CLI invocation

$ exec semedit insert-statement --help

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: unknown command

Structural overwrite requests fail through the public MCP tool without changing source.

Source: construct_overwrite_rejected_mcp.txtar · Download raw file

Execute: semedit mcp

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: supported keys

Execute: semedit mcp

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: supported keys

Execute: semedit mcp

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: construct_path.*non-empty string

Execute: semedit mcp

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: expected_revision.*non-empty string

Replace selected constructs and declarations; insertion collisions fail closed.

Source: construct_replacements.txtar · Download raw file

Execute: exec semedit replace-construct –file api/messages_test.go –in-function TestMessages –kind else –discriminator ’len(original) == 0’ –source ‘if condition {}’

CLI invocation

$ exec semedit replace-construct --file api/messages_test.go --in-function TestMessages --kind else --discriminator 'len(original) == 0' --source 'if condition {}'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: replacement must be one complete Go else construct

Execute: exec semedit insert-decl –file api/settings.go –source ‘var Revision = 2’

CLI invocation

$ exec semedit insert-decl --file api/settings.go --source 'var Revision = 2'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: Revision.*already exists

Execute: exec semedit insert-decl –file api/settings.go –overwrite –source ‘var Revision = 2’

CLI invocation

$ exec semedit insert-decl --file api/settings.go --overwrite --source 'var Revision = 2'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: unknown flag.*overwrite

Execute: semedit replace-construct –file api/settings.go –kind var –symbol Revision –source ‘var Revision = 2’

CLI invocation

$ semedit replace-construct --file api/settings.go --kind var --symbol Revision --source 'var Revision = 2'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "api/settings.go",
  "kind": "var",
  "source": "var Revision = 2",
  "symbol": "Revision"
}

Execute: semedit replace-construct –file api/settings.go –kind const –symbol DefaultLimit –source ‘const DefaultLimit = 10’

CLI invocation

$ semedit replace-construct --file api/settings.go --kind const --symbol DefaultLimit --source 'const DefaultLimit = 10'

Equivalent MCP tool call (semantic_replace_construct)

{
  "file": "api/settings.go",
  "kind": "const",
  "source": "const DefaultLimit = 10",
  "symbol": "DefaultLimit"
}

Execute: exec semedit replace-construct –file api/messages_test.go –in-function TestMessages –kind loop –discriminator want –source ‘for _, want := range []string{“alpha”}’

CLI invocation

$ exec semedit replace-construct --file api/messages_test.go --in-function TestMessages --kind loop --discriminator want --source 'for _, want := range []string{"alpha"}'

Equivalent MCP tool call (semedit_semedit)

{}

Execute: semedit replace-construct –file api/messages_test.go –in-function TestMessages –kind loop –discriminator want –source ‘for _, want := range []string{“alpha”, “beta”} { if want == "” { t.Fatal(want) } }’

CLI invocation

$ semedit replace-construct --file api/messages_test.go --in-function TestMessages --kind loop --discriminator want --source 'for _, want := range []string{"alpha", "beta"} { if want == "" { t.Fatal(want) } }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "discriminator": "want",
  "file": "api/messages_test.go",
  "in_function": "TestMessages",
  "kind": "loop",
  "source": "for _, want := range []string{\"alpha\", \"beta\"} { if want == \"\" { t.Fatal(want) } }"
}

Execute: exec semedit replace-construct –file api/loops_test.go –in-function TestAmbiguousLoops –kind loop –discriminator item –source ‘for _, item := range []string{“chosen”} { t.Log(item) }’

CLI invocation

$ exec semedit replace-construct --file api/loops_test.go --in-function TestAmbiguousLoops --kind loop --discriminator item --source 'for _, item := range []string{"chosen"} { t.Log(item) }'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: ambiguous loop

Execute: semedit replace-construct –file api/loops_test.go –in-function TestAmbiguousLoops –kind loop –discriminator item –construct-path 0 –source ‘for _, item := range []string{“chosen”} { t.Log(item) }’

CLI invocation

$ semedit replace-construct --file api/loops_test.go --in-function TestAmbiguousLoops --kind loop --discriminator item --construct-path 0 --source 'for _, item := range []string{"chosen"} { t.Log(item) }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "construct_path": "0",
  "discriminator": "item",
  "file": "api/loops_test.go",
  "in_function": "TestAmbiguousLoops",
  "kind": "loop",
  "source": "for _, item := range []string{\"chosen\"} { t.Log(item) }"
}

Execute: semedit replace-construct –file api/messages_test.go –in-function TestMessages –kind if –discriminator ’len(original) == 0’ –source ‘if len(original) > 0 { t.Log(“present”) } else { t.Log(“fallback”) }’

CLI invocation

$ semedit replace-construct --file api/messages_test.go --in-function TestMessages --kind if --discriminator 'len(original) == 0' --source 'if len(original) > 0 { t.Log("present") } else { t.Log("fallback") }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "discriminator": "len(original) == 0",
  "file": "api/messages_test.go",
  "in_function": "TestMessages",
  "kind": "if",
  "source": "if len(original) \u003e 0 { t.Log(\"present\") } else { t.Log(\"fallback\") }"
}

Execute: semedit replace-construct –file api/messages_test.go –in-function TestMessages –kind else –discriminator ’len(original) > 0’ –source ‘{ t.Fatal(“fallback”) }’

CLI invocation

$ semedit replace-construct --file api/messages_test.go --in-function TestMessages --kind else --discriminator 'len(original) > 0' --source '{ t.Fatal("fallback") }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "discriminator": "len(original) \u003e 0",
  "file": "api/messages_test.go",
  "in_function": "TestMessages",
  "kind": "else",
  "source": "{ t.Fatal(\"fallback\") }"
}

Unified AST transformation diff (api/loops_test.go)

  package api
  
  import "testing"
  
  func TestAmbiguousLoops(t *testing.T) {
  	for _, item := range []string{"first"} {
  		t.Log(item)
  	}
  	for _, item := range []string{"second"} {
  		t.Log(item)
  	}
  }

Expected output state (api/loops_test.go)

package api

import "testing"

func TestAmbiguousLoops(t *testing.T) {
	for _, item := range []string{"first"} {
		t.Log(item)
	}
	for _, item := range []string{"second"} {
		t.Log(item)
	}
}

Unified AST transformation diff (api/loops_test.go)

- 	for _, item := range []string{"first"} {
  package api
  
  import "testing"
  
  func TestAmbiguousLoops(t *testing.T) {
+ 	for _, item := range []string{"chosen"} {
  		t.Log(item)
  	}
  	for _, item := range []string{"second"} {
  		t.Log(item)
  	}
  }

Expected output state (api/loops_test.go)

package api

import "testing"

func TestAmbiguousLoops(t *testing.T) {
	for _, item := range []string{"chosen"} {
		t.Log(item)
	}
	for _, item := range []string{"second"} {
		t.Log(item)
	}
}

Unified AST transformation diff (api/messages_test.go)

  package api
  
  import "testing"
  
  func TestMessages(t *testing.T) {
  	original := []string{"old"}
  	if len(original) == 0 {
  		t.Fatal("missing originals")
  	} else {
  		t.Log("fallback")
  	}
  	for _, want := range original {
  		if want == "" {
  			t.Fatal(want)
  		}
  	}
  }

Expected output state (api/messages_test.go)

package api

import "testing"

func TestMessages(t *testing.T) {
	original := []string{"old"}
	if len(original) == 0 {
		t.Fatal("missing originals")
	} else {
		t.Log("fallback")
	}
	for _, want := range original {
		if want == "" {
			t.Fatal(want)
		}
	}
}

Unified AST transformation diff (api/messages_test.go)

- 	if len(original) == 0 {
- 		t.Fatal("missing originals")
- 		t.Log("fallback")
- 	for _, want := range original {
  package api
  
  import "testing"
  
  func TestMessages(t *testing.T) {
  	original := []string{"old"}
+ 	if len(original) > 0 {
+ 		t.Log("present")
  	} else {
+ 		t.Fatal("fallback")
  	}
+ 	for _, want := range []string{"alpha", "beta"} {
  		if want == "" {
  			t.Fatal(want)
  		}
  	}
  }

Expected output state (api/messages_test.go)

package api

import "testing"

func TestMessages(t *testing.T) {
	original := []string{"old"}
	if len(original) > 0 {
		t.Log("present")
	} else {
		t.Fatal("fallback")
	}
	for _, want := range []string{"alpha", "beta"} {
		if want == "" {
			t.Fatal(want)
		}
	}
}

Unified AST transformation diff (api/settings.go)

- const DefaultLimit = 5
- var Revision = 1
  package api
  
+ const DefaultLimit = 10
  
+ var Revision = 2

Expected output state (api/settings.go)

package api

const DefaultLimit = 10

var Revision = 2

Unified AST transformation diff (api/settings.go)

  package api
  
  const DefaultLimit = 5
  
  var Revision = 1

Expected output state (api/settings.go)

package api

const DefaultLimit = 5

var Revision = 1

Exercise generic construct replacements through MCP semantic_batch.

Source: construct_replacements_mcp_batch.txtar · Download raw file

Execute: semedit mcp

CLI invocation

$ semedit mcp

Equivalent MCP tool call (semedit_mcp)

{}

Assert: status":“ok

Unified AST transformation diff (api/messages_test.go)

- 	for _, want := range original {
  package api
  
  import "testing"
  
  func TestMessages(t *testing.T) {
  	original := []string{"old"}
  	if len(original) == 0 {
  		t.Fatal("missing originals")
  	}
+ 	for _, want := range []string{"alpha", "beta"} {
  		if want == "" {
  			t.Fatal(want)
  		}
  	}
  }

Expected output state (api/messages_test.go)

package api

import "testing"

func TestMessages(t *testing.T) {
	original := []string{"old"}
	if len(original) == 0 {
		t.Fatal("missing originals")
	}
	for _, want := range []string{"alpha", "beta"} {
		if want == "" {
			t.Fatal(want)
		}
	}
}

Unified AST transformation diff (api/settings.go)

- const DefaultLimit = 5
- var Revision = 1
  package api
  
+ const DefaultLimit = 10
  
+ var Revision = 2

Expected output state (api/settings.go)

package api

const DefaultLimit = 10

var Revision = 2

Generic replacement targets expression slots and whole statements by explicit selectors.

Source: construct_statement_expression_replacements.txtar · Download raw file

Execute: semedit replace-construct –file values.go –kind statement/expression –in-function Values –discriminator ‘1’ –source ‘3’

CLI invocation

$ semedit replace-construct --file values.go --kind statement/expression --in-function Values --discriminator '1' --source '3'

Equivalent MCP tool call (semantic_replace_construct)

{
  "discriminator": "1",
  "file": "values.go",
  "in_function": "Values",
  "kind": "statement/expression",
  "source": "3"
}

Execute: semedit replace-construct –file values.go –kind statement/expression –in-function Values –discriminator ‘value > 0’ –source ‘value > 2’

CLI invocation

$ semedit replace-construct --file values.go --kind statement/expression --in-function Values --discriminator 'value > 0' --source 'value > 2'

Equivalent MCP tool call (semantic_replace_construct)

{
  "discriminator": "value \u003e 0",
  "file": "values.go",
  "in_function": "Values",
  "kind": "statement/expression",
  "source": "value \u003e 2"
}

Execute: semedit replace-construct –file values.go –kind statement/expression –in-function Values –discriminator ‘return 2’ –source ‘if value > 0 { return 5 }’

CLI invocation

$ semedit replace-construct --file values.go --kind statement/expression --in-function Values --discriminator 'return 2' --source 'if value > 0 { return 5 }'

Equivalent MCP tool call (semantic_replace_construct)

{
  "discriminator": "return 2",
  "file": "values.go",
  "in_function": "Values",
  "kind": "statement/expression",
  "source": "if value \u003e 0 { return 5 }"
}

Execute: exec semedit replace-construct –file values.go –kind statement/expression –in-function Repeated –discriminator ‘1’ –source ‘9’

CLI invocation

$ exec semedit replace-construct --file values.go --kind statement/expression --in-function Repeated --discriminator '1' --source '9'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: ambiguous.*construct_path

Execute: semedit replace-construct –file values.go –kind statement/expression –in-function Repeated –discriminator ‘1’ –construct-path 1.e0 –source ‘9’

CLI invocation

$ semedit replace-construct --file values.go --kind statement/expression --in-function Repeated --discriminator '1' --construct-path 1.e0 --source '9'

Equivalent MCP tool call (semantic_replace_construct)

{
  "construct_path": "1.e0",
  "discriminator": "1",
  "file": "values.go",
  "in_function": "Repeated",
  "kind": "statement/expression",
  "source": "9"
}

Execute: exec semedit replace-construct –file values.go –kind statement/expression –in-function Shared –discriminator ‘callValue()’ –source ‘return’

CLI invocation

$ exec semedit replace-construct --file values.go --kind statement/expression --in-function Shared --discriminator 'callValue()' --source 'return'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: ambiguous.*construct_path

Execute: semedit replace-construct –file values.go –kind statement/expression –in-function Shared –discriminator ‘callValue()’ –construct-path 0.e0 –source ‘recordValue()’

CLI invocation

$ semedit replace-construct --file values.go --kind statement/expression --in-function Shared --discriminator 'callValue()' --construct-path 0.e0 --source 'recordValue()'

Equivalent MCP tool call (semantic_replace_construct)

{
  "construct_path": "0.e0",
  "discriminator": "callValue()",
  "file": "values.go",
  "in_function": "Shared",
  "kind": "statement/expression",
  "source": "recordValue()"
}

Execute: semedit replace-construct –file values.go –kind statement/expression –in-function Index –discriminator ‘items[17]’ –source ‘items[18]’

CLI invocation

$ semedit replace-construct --file values.go --kind statement/expression --in-function Index --discriminator 'items[17]' --source 'items[18]'

Equivalent MCP tool call (semantic_replace_construct)

{
  "discriminator": "items[17]",
  "file": "values.go",
  "in_function": "Index",
  "kind": "statement/expression",
  "source": "items[18]"
}

Execute: semedit replace-construct –file values.go –kind statement/expression –in-function RuntimeNew –discriminator ’new(value)’ –source ’new(value + 1)’

CLI invocation

$ semedit replace-construct --file values.go --kind statement/expression --in-function RuntimeNew --discriminator 'new(value)' --source 'new(value + 1)'

Equivalent MCP tool call (semantic_replace_construct)

{
  "discriminator": "new(value)",
  "file": "values.go",
  "in_function": "RuntimeNew",
  "kind": "statement/expression",
  "source": "new(value + 1)"
}

Execute: exec semedit replace-construct –file values.go –kind statement/expression –in-function Values –discriminator ‘3’ –source ‘if (’

CLI invocation

$ exec semedit replace-construct --file values.go --kind statement/expression --in-function Values --discriminator '3' --source 'if ('

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: syntax|expression

Execute: exec semedit replace-construct –file values.go –kind statement/expression –in-function Injection –discriminator ‘1’ –source ‘2); injected()’

CLI invocation

$ exec semedit replace-construct --file values.go --kind statement/expression --in-function Injection --discriminator '1' --source '2); injected()'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: syntax|expression

Execute: exec semedit replace-construct –file values.go –kind statement/expression –in-function TypeOnly –discriminator int –source string

CLI invocation

$ exec semedit replace-construct --file values.go --kind statement/expression --in-function TypeOnly --discriminator int --source string

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: not found|match

Execute: exec semedit replace-construct –file values.go –kind statement/expression –in-function ParenthesizedMake –discriminator ‘[]int’ –source ‘[]string’

CLI invocation

$ exec semedit replace-construct --file values.go --kind statement/expression --in-function ParenthesizedMake --discriminator '[]int' --source '[]string'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: not found|match

Execute: exec semedit replace-construct –file values.go –kind statement/expression –in-function ParenthesizedNew –discriminator int –source string

CLI invocation

$ exec semedit replace-construct --file values.go --kind statement/expression --in-function ParenthesizedNew --discriminator int --source string

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: not found|match

Execute: exec semedit replace-construct –file values.go –kind statement/expression –in-function Commented –discriminator ‘old()’ –construct-path 0 –source ’next() // keep this trailing comment’

CLI invocation

$ exec semedit replace-construct --file values.go --kind statement/expression --in-function Commented --discriminator 'old()' --construct-path 0 --source 'next() // keep this trailing comment'

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: comment|trailing

Insert around unique direct statement anchors with no expression round trip.

Source: construct_statement_insertion.txtar · Download raw file

Repeated anchors bind both the candidate path and exact file revision. Unique direct statement anchors need no candidate path or revision. Repeated direct statement anchors require a candidate path.

Execute: exec semedit insert-construct –file server.go –kind statement/expression –in-function Two –discriminator ‘flush()’ –source ‘record()’ –anchor after

CLI invocation

$ exec semedit insert-construct --file server.go --kind statement/expression --in-function Two --discriminator 'flush()' --source 'record()' --anchor after

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: ambiguous.*expected_revision

Execute: exec semedit insert-construct –file server.go –kind statement/expression –in-function Two –discriminator ‘flush()’ –construct-path 0 –source ‘record()’ –anchor after

CLI invocation

$ exec semedit insert-construct --file server.go --kind statement/expression --in-function Two --discriminator 'flush()' --construct-path 0 --source 'record()' --anchor after

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: expected_revision

Execute: exec semedit insert-construct –file server.go –kind statement/expression –in-function Two –discriminator ‘flush()’ –construct-path 0 –expected-revision stale –source ‘record()’ –anchor after

CLI invocation

$ exec semedit insert-construct --file server.go --kind statement/expression --in-function Two --discriminator 'flush()' --construct-path 0 --expected-revision stale --source 'record()' --anchor after

Equivalent MCP tool call (semedit_semedit)

{}

Expected error: revision

Execute: semedit insert-construct –file server.go –kind statement/expression –in-function Two –discriminator ‘flush()’ –construct-path 0 –expected-revision 90761e0366f5d16fe48024fe40827de492f5eae767e189b59e6829c99dc7ad8d –source ‘record()’ –anchor after

CLI invocation

$ semedit insert-construct --file server.go --kind statement/expression --in-function Two --discriminator 'flush()' --construct-path 0 --expected-revision 90761e0366f5d16fe48024fe40827de492f5eae767e189b59e6829c99dc7ad8d --source 'record()' --anchor after

Equivalent MCP tool call (semantic_insert_construct)

{
  "anchor": "after",
  "construct_path": "0",
  "discriminator": "flush()",
  "expected_revision": "90761e0366f5d16fe48024fe40827de492f5eae767e189b59e6829c99dc7ad8d",
  "file": "server.go",
  "in_function": "Two",
  "kind": "statement/expression",
  "source": "record()"
}

Execute: semedit insert-construct –file server.go –kind statement/expression –in-function ‘(*Server).Run’ –discriminator ‘flush()’ –source ‘record()’ –anchor before

CLI invocation

$ semedit insert-construct --file server.go --kind statement/expression --in-function '(*Server).Run' --discriminator 'flush()' --source 'record()' --anchor before

Equivalent MCP tool call (semantic_insert_construct)

{
  "anchor": "before",
  "discriminator": "flush()",
  "file": "server.go",
  "in_function": "(*Server).Run",
  "kind": "statement/expression",
  "source": "record()"
}