Skip to contents

Changelog

Source: NEWS.md

insideR (development version)

  • unpack_call(), propose_change(), bundle(), and diff_versions() gain optional store, store_label, and store_tags arguments. When store (an insider_store handle) is supplied, the returned artifact is also recorded via store_save() in one call instead of a separate manual step, and the resulting id is attached as the artifact’s "store_id" attribute. The default, store = NULL, records nothing, consistent with the store’s existing explicit, opt-in design.

  • diff_versions() now supports whole-package diffing: name is optional, and name = NULL (the default) diffs every function in scope ("exported", the default, or "all" for internal functions too) across two installed versions, using one extraction subprocess per version instead of one per function. Returns an insider_diff_package object with a per-function summary (added/removed/changed/identical, line-diff counts, formal changes) plus diffs, a named list of the same insider_diff objects the single-function form returns.

  • Added bundle() to copy one or more written unpack_call()/ propose_change() results into a single shareable handoff directory, running the secret-shaped-value gate (scan_secrets() for replay projects, a textual artifact scan for proposals) across every item first. on_secret controls whether a flagged value warns (default), aborts before anything is written, or is recorded for later review without warning. propose_change() now also records the output_dir it was written to (NULL when not written to disk).

  • propose_change() now redacts secret-shaped values and short values assigned to credential-named arguments from returned, printed, and written proposal content. on_secret = "abort" blocks proposal creation when sensitive-looking call or patched-error text is detected.

  • JSON artifacts now use standards-compliant jsonlite serialization with documented null handling for missing and non-finite values.

  • Graph nodes now carry stable qualified identities and short display labels; graph traversal uses qualified edge endpoints and rejects ambiguous unqualified lookups instead of silently choosing the first definition.

  • 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.