necropsy 0.2.0 → 0.3.0

data/lib/necropsy/world_policy.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Necropsy
+  class WorldPolicy
+    def initialize(graph:, project:)
+      @graph = graph
+      @project = project
+    end
+
+    def apply
+      protect_library_surface if config.library_world?
+      add_conservative_load_roots if config.load_roots == :all
+      LoadGraph.new(graph: graph, project: project).apply
+      record_policy
+    end
+
+    private
+
+    attr_reader :graph, :project
+
+    def config
+      project.config
+    end
+
+    def protect_library_surface
+      graph.method_nodes.reject(&:test).select { |node| %i[public protected].include?(node.visibility) }.each do |node|
+        graph.add_entry_point(
+          node.graph_id,
+          :library_public_api,
+          domain: :external,
+          evidence: {
+            'type' => 'world_policy',
+            'world' => 'library',
+            'visibility' => node.visibility.to_s
+          }
+        )
+        graph.add_blocker(open_public_api_blocker(node))
+      end
+    end
+
+    def open_public_api_blocker(node)
+      Blocker.new(
+        kind: :open_public_api,
+        scope_kind: :definition,
+        scope_value: node.graph_id,
+        source: :world_policy,
+        reason: 'Library public and protected APIs may have callers outside the repository',
+        suggested_action: :review_external_contract,
+        metadata: {
+          'caller_domain' => 'runtime',
+          'root_domain' => 'external',
+          'receiver_kind' => 'implicit',
+          'world' => 'library',
+          'visibility' => node.visibility.to_s
+        }
+      )
+    end
+
+    def add_conservative_load_roots
+      graph.nodes.values.select { |node| node.kind == :block_entry && !node.test }.each do |node|
+        graph.add_entry_point(
+          node.graph_id,
+          :production_load_unit,
+          domain: :runtime,
+          evidence: {
+            'type' => 'load_policy',
+            'policy' => 'all',
+            'file' => node.file
+          }
+        )
+      end
+    end
+
+    def record_policy
+      graph.observation['world_policy'] = {
+        'world' => config.world.to_s,
+        'load_roots' => config.load_roots.to_s,
+        'configuration_sha256' => configuration_digest
+      }
+    end
+
+    def configuration_digest
+      Digest::SHA256.hexdigest(BoundedCanonicalizer.dump(config.scan_cache_key))
+    rescue StandardError, SystemStackError
+      'unavailable'
+    end
+  end
+end

data/lib/necropsy.rb

@@ -4,16 +4,35 @@
 require 'set' # rubocop:disable Lint/RedundantRequireStatement
 
 require_relative 'necropsy/version'
+require_relative 'necropsy/clock'
+require_relative 'necropsy/bounded_canonicalizer'
+require_relative 'necropsy/call_site_identity'
 require_relative 'necropsy/models'
+require_relative 'necropsy/definition_identity'
 require_relative 'necropsy/configuration'
+require_relative 'necropsy/flow_interpreter'
+require_relative 'necropsy/convention_rules'
+require_relative 'necropsy/type_facts'
+require_relative 'necropsy/runtime_feedback'
+require_relative 'necropsy/performance_profiler'
+require_relative 'necropsy/embedded_ruby'
 require_relative 'necropsy/ast_scanner'
 require_relative 'necropsy/cache/scan_cache'
 require_relative 'necropsy/project'
+require_relative 'necropsy/graph/definition_index'
+require_relative 'necropsy/graph/dynamic_evidence_tracking'
+require_relative 'necropsy/graph/evidence_store'
+require_relative 'necropsy/graph/blocker_matching'
+require_relative 'necropsy/graph/resolution_store'
 require_relative 'necropsy/graph/call_graph'
+require_relative 'necropsy/graph_self_check'
+require_relative 'necropsy/semantics_matrix'
 require_relative 'necropsy/analyzer'
+require_relative 'necropsy/analyzers/legacy_result_adapter'
 require_relative 'necropsy/analyzers/static/name_resolution'
 require_relative 'necropsy/analyzers/static/cha'
 require_relative 'necropsy/analyzers/static/rta'
+require_relative 'necropsy/analyzers/dynamic/observation_policy'
 require_relative 'necropsy/analyzers/dynamic/coverage_importer'
 require_relative 'necropsy/analyzers/dynamic/coverage_collector'
 require_relative 'necropsy/analyzers/dynamic/coverband_importer'
@@ -22,22 +41,36 @@ require_relative 'necropsy/analyzers/dynamic/trace_point_collector'
 require_relative 'necropsy/entry_points/plain'
 require_relative 'necropsy/entry_points/rails'
 require_relative 'necropsy/entry_points/test'
+require_relative 'necropsy/load_graph'
+require_relative 'necropsy/world_policy'
 require_relative 'necropsy/reachability/engine'
 require_relative 'necropsy/confidence/scorer'
 require_relative 'necropsy/report'
 require_relative 'necropsy/reporter'
+require_relative 'necropsy/why_not_explanation'
+require_relative 'necropsy/why_not_renderer'
 require_relative 'necropsy/diagnostics'
+require_relative 'necropsy/reference_barrier'
 require_relative 'necropsy/guardrail/baseline'
 require_relative 'necropsy/guardrail/diff'
 require_relative 'necropsy/guardrail/quarantine'
+require_relative 'necropsy/bench/finding_facts'
 require_relative 'necropsy/bench/evaluator'
+require_relative 'necropsy/bench/claim_gate'
+require_relative 'necropsy/bench/review_queue'
 require_relative 'necropsy/runner'
 
 module Necropsy
   class Error < StandardError; end
 
-  def self.analyze(root: '.', config_path: nil, analyzers: nil)
-    Runner.new(root: root, config_path: config_path, analyzers: analyzers).analyze
+  def self.analyze(root: '.', config_path: nil, analyzers: nil, ignored_reference_paths: [], profile: false, as_of: nil)
+    Runner.new(
+      root: root,
+      config_path: config_path,
+      analyzers: analyzers,
+      ignored_reference_paths: ignored_reference_paths,
+      as_of: as_of
+    ).analyze(profile: profile)
   end
 
   def self.default_analyzers

data/schema/necropsy-report-v2.schema.json

@@ -0,0 +1,366 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/ydah/necropsy/blob/main/schema/necropsy-report-v2.schema.json",
+  "title": "Necropsy report v2",
+  "description": "Stable machine-readable report emitted by Necropsy JSON and YAML reporters.",
+  "type": "object",
+  "required": [
+    "schema_version",
+    "artifact_provenance",
+    "compatibility",
+    "root",
+    "analysis_health",
+    "summary",
+    "findings"
+  ],
+  "properties": {
+    "schema_version": { "const": 2 },
+    "artifact_provenance": { "$ref": "#/$defs/artifactProvenance" },
+    "compatibility": { "$ref": "#/$defs/compatibility" },
+    "root": { "type": "string", "minLength": 1 },
+    "analysis_health": { "$ref": "#/$defs/analysisHealth" },
+    "summary": { "$ref": "#/$defs/summary" },
+    "findings": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/finding" }
+    },
+    "diagnostics": { "type": "object" },
+    "source_snapshot": { "$ref": "#/$defs/sourceSnapshot" },
+    "graph": { "$ref": "#/$defs/graph" }
+  },
+  "additionalProperties": true,
+  "$defs": {
+    "sha256": {
+      "type": "string",
+      "pattern": "^[0-9a-f]{64}$"
+    },
+    "artifactProvenance": {
+      "type": "object",
+      "required": ["producer", "runtime", "identity_schemas", "inputs"],
+      "properties": {
+        "producer": {
+          "type": "object",
+          "required": ["name", "version"],
+          "properties": {
+            "name": { "const": "necropsy" },
+            "version": { "type": "string", "minLength": 1 }
+          },
+          "additionalProperties": true
+        },
+        "runtime": {
+          "type": "object",
+          "required": ["ruby_engine", "ruby_version", "prism_version"],
+          "properties": {
+            "ruby_engine": { "type": "string", "minLength": 1 },
+            "ruby_version": { "type": "string", "minLength": 1 },
+            "prism_version": { "type": "string", "minLength": 1 }
+          },
+          "additionalProperties": true
+        },
+        "identity_schemas": {
+          "type": "object",
+          "required": ["definition", "call_site"],
+          "properties": {
+            "definition": { "type": "integer", "minimum": 1 },
+            "call_site": { "type": "integer", "minimum": 1 }
+          },
+          "additionalProperties": true
+        },
+        "inputs": {
+          "type": "object",
+          "required": ["configuration_sha256"],
+          "properties": {
+            "configuration_sha256": {
+              "oneOf": [
+                { "$ref": "#/$defs/sha256" },
+                { "const": "unavailable" }
+              ]
+            }
+          },
+          "additionalProperties": true
+        }
+      },
+      "additionalProperties": true
+    },
+    "compatibility": {
+      "type": "object",
+      "required": ["finding_fingerprints"],
+      "properties": {
+        "finding_fingerprints": {
+          "type": "object",
+          "required": ["fingerprint", "physical_fingerprint"],
+          "properties": {
+            "fingerprint": { "type": "string", "minLength": 1 },
+            "physical_fingerprint": { "type": "string", "minLength": 1 }
+          },
+          "additionalProperties": true
+        }
+      },
+      "additionalProperties": true
+    },
+    "analysisHealth": {
+      "type": "object",
+      "required": ["status", "reasons"],
+      "properties": {
+        "status": { "enum": ["complete", "degraded", "invalid"] },
+        "reasons": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["severity", "code"],
+            "properties": {
+              "severity": { "enum": ["degraded", "invalid"] },
+              "code": { "type": "string", "minLength": 1 },
+              "message": { "type": "string" },
+              "file": { "type": "string" },
+              "line": { "type": "integer", "minimum": 1 }
+            },
+            "additionalProperties": true
+          }
+        }
+      },
+      "additionalProperties": true
+    },
+    "summary": {
+      "type": "object",
+      "required": [
+        "nodes",
+        "edges",
+        "entry_points",
+        "incomplete_files",
+        "findings",
+        "actionable",
+        "diagnostic",
+        "health_failures",
+        "unreachable",
+        "unused",
+        "blocked",
+        "test_only_reachable"
+      ],
+      "properties": {
+        "nodes": { "$ref": "#/$defs/count" },
+        "edges": { "$ref": "#/$defs/count" },
+        "entry_points": { "$ref": "#/$defs/count" },
+        "incomplete_files": { "$ref": "#/$defs/count" },
+        "findings": { "$ref": "#/$defs/count" },
+        "actionable": { "$ref": "#/$defs/count" },
+        "diagnostic": { "$ref": "#/$defs/count" },
+        "health_failures": { "$ref": "#/$defs/count" },
+        "unreachable": { "$ref": "#/$defs/count" },
+        "unused": { "$ref": "#/$defs/count" },
+        "blocked": { "$ref": "#/$defs/count" },
+        "test_only_reachable": { "$ref": "#/$defs/count" }
+      },
+      "additionalProperties": true
+    },
+    "count": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "finding": {
+      "type": "object",
+      "required": [
+        "fingerprint",
+        "logical_fingerprint",
+        "physical_fingerprint",
+        "classification",
+        "confidence",
+        "score",
+        "score_components",
+        "node",
+        "reasons",
+        "evidences",
+        "blockers"
+      ],
+      "properties": {
+        "fingerprint": { "$ref": "#/$defs/sha256" },
+        "logical_fingerprint": { "$ref": "#/$defs/sha256" },
+        "physical_fingerprint": { "$ref": "#/$defs/sha256" },
+        "classification": {
+          "enum": ["unreachable", "unused", "blocked", "test_only_reachable"]
+        },
+        "confidence": { "enum": ["low", "medium", "high", "certain"] },
+        "score": { "type": "number", "minimum": 0, "maximum": 1 },
+        "score_components": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/scoreComponent" }
+        },
+        "node": { "$ref": "#/$defs/node" },
+        "reasons": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "evidences": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/evidence" }
+        },
+        "blockers": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/blocker" }
+        }
+      },
+      "additionalProperties": true
+    },
+    "node": {
+      "type": "object",
+      "required": [
+        "id",
+        "symbol_id",
+        "definition_id",
+        "body_digest",
+        "ordinal",
+        "kind",
+        "file",
+        "line",
+        "end_line",
+        "defined_via",
+        "owner",
+        "name",
+        "test",
+        "visibility"
+      ],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "symbol_id": { "type": "string", "minLength": 1 },
+        "definition_id": { "type": "string", "minLength": 1 },
+        "body_digest": {
+          "oneOf": [
+            { "$ref": "#/$defs/sha256" },
+            { "type": "null" }
+          ]
+        },
+        "ordinal": { "type": "integer", "minimum": 0 },
+        "kind": { "type": "string", "minLength": 1 },
+        "file": { "type": "string", "minLength": 1 },
+        "line": { "type": "integer", "minimum": 1 },
+        "end_line": { "type": "integer", "minimum": 1 },
+        "defined_via": { "type": "string", "minLength": 1 },
+        "owner": { "type": ["string", "null"] },
+        "name": { "type": ["string", "null"] },
+        "test": { "type": "boolean" },
+        "visibility": { "enum": ["public", "protected", "private"] }
+      },
+      "additionalProperties": true
+    },
+    "scoreComponent": {
+      "type": "object",
+      "required": ["name", "value", "details"],
+      "properties": {
+        "name": { "type": "string", "minLength": 1 },
+        "value": { "type": "number" },
+        "details": { "type": "string" }
+      },
+      "additionalProperties": true
+    },
+    "evidence": {
+      "type": "object",
+      "required": [
+        "analyzer",
+        "kind",
+        "weight",
+        "details",
+        "metadata",
+        "evidence_id",
+        "producer",
+        "producer_version",
+        "grade",
+        "relation",
+        "source",
+        "assumptions",
+        "scope"
+      ],
+      "properties": {
+        "analyzer": { "type": "string", "minLength": 1 },
+        "kind": { "type": "string", "minLength": 1 },
+        "weight": { "type": "number" },
+        "details": { "type": "string" },
+        "metadata": { "type": "object" },
+        "evidence_id": { "type": ["string", "null"] },
+        "producer": { "type": ["string", "null"] },
+        "producer_version": { "type": ["string", "null"] },
+        "grade": {
+          "oneOf": [
+            { "enum": ["exact", "conservative", "observed", "heuristic"] },
+            { "type": "null" }
+          ]
+        },
+        "relation": { "type": ["string", "null"] },
+        "source": {},
+        "assumptions": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "scope": {}
+      },
+      "additionalProperties": true
+    },
+    "blocker": {
+      "type": "object",
+      "required": ["kind", "scope_kind", "scope_value", "source", "reason", "suggested_action", "metadata"],
+      "properties": {
+        "kind": { "type": "string", "minLength": 1 },
+        "scope_kind": { "type": "string", "minLength": 1 },
+        "scope_value": {},
+        "source": {},
+        "reason": { "type": "string", "minLength": 1 },
+        "suggested_action": { "type": "string", "minLength": 1 },
+        "metadata": { "type": "object" }
+      },
+      "additionalProperties": true
+    },
+    "sourceSnapshot": {
+      "type": "object",
+      "required": ["status", "sha256"],
+      "properties": {
+        "status": { "enum": ["complete", "unavailable"] },
+        "sha256": {
+          "oneOf": [
+            { "$ref": "#/$defs/sha256" },
+            { "const": "unavailable" }
+          ]
+        },
+        "files": { "$ref": "#/$defs/count" },
+        "bytes": { "$ref": "#/$defs/count" },
+        "reason": { "type": "string" },
+        "verification": { "type": "object" }
+      },
+      "additionalProperties": true
+    },
+    "graph": {
+      "type": "object",
+      "required": [
+        "nodes",
+        "call_sites",
+        "edges",
+        "edge_projection",
+        "edge_relations",
+        "evidence_records",
+        "entry_points",
+        "profiles",
+        "resolutions",
+        "blockers",
+        "file_statuses",
+        "source_errors",
+        "source_domains",
+        "observation"
+      ],
+      "properties": {
+        "nodes": { "type": "array", "items": { "$ref": "#/$defs/node" } },
+        "call_sites": { "type": "array" },
+        "edges": { "type": "array" },
+        "edge_projection": { "const": "conservative" },
+        "edge_relations": { "type": "array" },
+        "evidence_records": { "type": "array", "items": { "$ref": "#/$defs/evidence" } },
+        "entry_points": { "type": "array" },
+        "profiles": { "type": "array" },
+        "resolutions": { "type": "array" },
+        "blockers": { "type": "array", "items": { "$ref": "#/$defs/blocker" } },
+        "file_statuses": { "type": "object" },
+        "source_errors": { "type": "array" },
+        "source_domains": { "type": "object" },
+        "observation": { "type": "object" }
+      },
+      "additionalProperties": true
+    }
+  }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: necropsy
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -44,47 +44,131 @@ files:
 - MEASUREMENTS.md
 - README.md
 - Rakefile
+- bench/README.md
+- bench/audit.rb
+- bench/audits/0.2.1/audit.json
+- bench/audits/0.2.1/audit.md
+- bench/audits/0.2.1/baseline_performance.yml
+- bench/audits/0.2.1/config.yml
+- bench/audits/0.2.1/review.yml
+- bench/audits/0.2.1/review_queue.yml
+- bench/corpora/v1/README.md
+- bench/corpora/v1/labels.yml
+- bench/corpora/v1/manifest.yml
+- bench/corpora/v1/rubocop.necropsy.yml
+- bench/corpora/v1/self.necropsy.yml
+- bench/corpora/v1/tools/debride.yml
+- bench/corpora/v1/tools/spoom.yml
+- bench/corpora/v1/tools/type_aware.yml
+- bench/golden/v1/candidate_union.json
+- bench/golden/v1/metadata.json
+- bench/golden/v1/reports/dynamic_evidence.json
+- bench/golden/v1/reports/plain_ruby.json
+- bench/golden/v1/reports/rails.json
+- bench/golden/v1/reports/rubocop_1_75_0.json
+- bench/golden/v1/reports/self.json
+- bench/review_queue.rb
+- bench/run.rb
+- bench/schema/candidate-union-v1.schema.json
+- docs/impv_implementation_matrix.md
+- docs/migrations/0.2.1.md
+- docs/migrations/0.3.0.md
+- docs/migrations/0.4.0.md
+- docs/necropsy_performance_adr.md
+- docs/necropsy_scope_decisions.md
+- docs/necropsy_type_facts_adr.md
 - exe/necropsy
+- gemfiles/prism_min.gemfile
+- gemfiles/prism_min.gemfile.lock
 - lib/necropsy.rb
 - lib/necropsy/analyzer.rb
 - lib/necropsy/analyzers/dynamic/coverage_collector.rb
 - lib/necropsy/analyzers/dynamic/coverage_importer.rb
 - lib/necropsy/analyzers/dynamic/coverband_importer.rb
+- lib/necropsy/analyzers/dynamic/coverband_payload_set.rb
+- lib/necropsy/analyzers/dynamic/observation_policy.rb
+- lib/necropsy/analyzers/dynamic/redis_input_limits.rb
+- lib/necropsy/analyzers/dynamic/redis_nonblocking_io.rb
+- lib/necropsy/analyzers/dynamic/redis_payload_loader.rb
+- lib/necropsy/analyzers/dynamic/redis_transport.rb
+- lib/necropsy/analyzers/dynamic/runtime_reference.rb
 - lib/necropsy/analyzers/dynamic/trace_point_collector.rb
 - lib/necropsy/analyzers/dynamic/trace_point_importer.rb
+- lib/necropsy/analyzers/legacy_result_adapter.rb
 - lib/necropsy/analyzers/static/cha.rb
 - lib/necropsy/analyzers/static/name_resolution.rb
 - lib/necropsy/analyzers/static/rta.rb
 - lib/necropsy/ast_scanner.rb
 - lib/necropsy/ast_scanner/call_recording.rb
+- lib/necropsy/ast_scanner/call_site_creation.rb
+- lib/necropsy/ast_scanner/definition_creation.rb
 - lib/necropsy/ast_scanner/dsl_macros.rb
 - lib/necropsy/ast_scanner/method_definitions.rb
 - lib/necropsy/ast_scanner/references.rb
 - lib/necropsy/ast_scanner/ruby_semantics.rb
 - lib/necropsy/ast_scanner/traversal.rb
 - lib/necropsy/ast_scanner/value_definitions.rb
+- lib/necropsy/bench/candidate_union.rb
+- lib/necropsy/bench/claim_gate.rb
 - lib/necropsy/bench/evaluator.rb
+- lib/necropsy/bench/finding_facts.rb
+- lib/necropsy/bench/precision_gate.rb
+- lib/necropsy/bench/release_audit.rb
+- lib/necropsy/bench/release_audit/adversarial_runner.rb
+- lib/necropsy/bench/release_audit/artifact_writer.rb
+- lib/necropsy/bench/release_audit/config_validator.rb
+- lib/necropsy/bench/release_audit/git_snapshot.rb
+- lib/necropsy/bench/release_audit/performance_gate.rb
+- lib/necropsy/bench/release_audit/run_provenance.rb
+- lib/necropsy/bench/report_normalizer.rb
+- lib/necropsy/bench/review_queue.rb
+- lib/necropsy/bench/safety_mutation_harness.rb
+- lib/necropsy/bench/seed_runner.rb
+- lib/necropsy/bounded_canonicalizer.rb
 - lib/necropsy/cache/scan_cache.rb
+- lib/necropsy/call_site_identity.rb
 - lib/necropsy/cli.rb
+- lib/necropsy/clock.rb
 - lib/necropsy/confidence/scorer.rb
 - lib/necropsy/configuration.rb
+- lib/necropsy/convention_rules.rb
 - lib/necropsy/coverage_runtime.rb
+- lib/necropsy/definition_identity.rb
+- lib/necropsy/definition_identity/canonical_digest.rb
 - lib/necropsy/diagnostics.rb
+- lib/necropsy/embedded_ruby.rb
 - lib/necropsy/entry_points/plain.rb
 - lib/necropsy/entry_points/rails.rb
 - lib/necropsy/entry_points/test.rb
+- lib/necropsy/flow_interpreter.rb
+- lib/necropsy/graph/blocker_matching.rb
 - lib/necropsy/graph/call_graph.rb
+- lib/necropsy/graph/definition_index.rb
+- lib/necropsy/graph/dynamic_evidence_tracking.rb
+- lib/necropsy/graph/evidence_store.rb
+- lib/necropsy/graph/resolution_store.rb
+- lib/necropsy/graph_self_check.rb
 - lib/necropsy/guardrail/baseline.rb
 - lib/necropsy/guardrail/diff.rb
 - lib/necropsy/guardrail/quarantine.rb
+- lib/necropsy/load_graph.rb
 - lib/necropsy/models.rb
+- lib/necropsy/performance_profiler.rb
 - lib/necropsy/project.rb
 - lib/necropsy/reachability/engine.rb
+- lib/necropsy/reference_barrier.rb
 - lib/necropsy/report.rb
 - lib/necropsy/reporter.rb
 - lib/necropsy/runner.rb
+- lib/necropsy/runtime_feedback.rb
+- lib/necropsy/semantics_matrix.rb
 - lib/necropsy/trace_point_runtime.rb
+- lib/necropsy/type_facts.rb
 - lib/necropsy/version.rb
+- lib/necropsy/why_not_explanation.rb
+- lib/necropsy/why_not_renderer.rb
+- lib/necropsy/world_policy.rb
+- schema/necropsy-report-v2.schema.json
 - script/measure.rb
 homepage: https://github.com/ydah/necropsy
 licenses: