Skip to contents

Changelog

Source: NEWS.md

insideR (development version)

  • Added build_context() to generate compact markdown or JSON agent context for a named package entry point before a concrete call has been captured.

  • Added resolve_dependencies() and slice_call(). Call slices now include a versioned dependencies.json, compact Markdown/JSON agent context, and a validation-plan skeleton separating extractable, external, and unknown work.

  • Runtime trace printing now includes observed S3 dispatch-class evidence and conservative argument summaries for the already-forced dispatch object.

  • Added shallow, error-safe runtime tracing with trace_call() and compact insider_trace printing, including observed S3 method selection.

  • Added explain_error() to show package-internal traceback frames, source, and captured failing-frame arguments when available.

  • unpack_call() now defaults to extracting package-internal S3 method candidates when dispatch cannot be resolved statically, allowing UseMethod() to choose correctly at replay time. Set dispatch = "static" for the previous behavior. Candidate extraction has a configurable insider.max_candidate_fns size guard and is reported separately in the replay header and status object.

  • Replay scripts now capture hidden state the call silently depends on (stored in data/hidden_state.rds): behavior-changing options (contrasts, na.action) are always captured and restored; RNGkind()/.Random.seed are captured and restored when the extracted call path uses random-number functions, so RNG-dependent replays reproduce the original draws. The script header lists what was restored, what is reported only (locale, timezone), and what could not be captured (e.g. RNG use in a session with no RNG state yet).

  • The printed “Run it with” hint after unpack_call() now uses forward-slash paths (pasteable on Windows, where C:\Users\... is invalid R string syntax) and, for "partial" replays, warns to read the script’s Limitations header first, naming the unresolved generic the replay is expected to stop at.

  • Graph edges now record how each relationship was discovered and how reliable it is: new g$edges columns provenance (e.g. static_parse, codetools), confidence (0–1, defaulted by provenance), resolved, and notes.

  • New g$unresolved table exposes references static analysis cannot pin to one target (ambiguous S3/S4 generic calls such as predict(x)), with candidates and a reason, instead of dropping them silently.

  • Graph objects carry a schema version; cached graphs written by older versions (.insider_graph.rds, user-cache RDS) are detected as stale and rebuilt automatically.

  • Added GitHub Actions CI (R CMD check matrix; warnings fail the build) and Actions-based pkgdown deployment. BugReports added to DESCRIPTION.

  • The package was renamed from transR to insider (brand: insideR). This is a pure rename: no API or behavioral changes. Saved transR_graph RDS caches (.transR_graph.rds) and transR_manifest.rds files written by old replay projects from prior transR versions are not compatible with this version — regenerate them with the new insider package.

insideR 0.2.0

  • New code-graph module (codegraph-style functionality, native R):
    • build_graph() indexes a source directory (static parsing, exact files/lines, nothing executed) or an installed package (namespace introspection) into nodes (functions, objects, S4/R5/R6 classes and methods), call edges, and imports.
    • graph_search(), graph_node(), graph_callers(), graph_callees() query the graph; all accept a built graph or a target string.
    • RDS caching with automatic invalidation on file changes (source mode) or version change (installed mode).

insideR 0.1.0

  • First working milestone: explain_call() and unpack_call() for plain R functions and S3 methods.
  • unpack_call() writes a self-contained replay.R (documented extracted functions, captured inputs, reproducing call, built-in verification against the stored original result and a live package call).
  • Static security scan of extracted code (shell execution, network access, dynamic evaluation, file writes, global-state mutation, compiled entry points), reported in explain_call() output and the script header.