Skip to main content

ASK Engine

ASK — Actionable Software Knowledge. Persistent structural intelligence for AI coding agents.

Context · Impact · Migration · Architecture · Review — everything from one structural model.

First run. From the repository you want to inspect, run ask --help and then ask . --compact. Use ask endpoints ., ask spring-audit ., ask migrate-check . --compact, or ask impact <Interface> . for a specific question. All analysis is local and deterministic; see Privacy before inspecting a repository whose telemetry policy you need to control.

Version Python

Copyright (c) 2026 Dominique Haroun. All rights reserved. ASK Engine 5.7.0 and later are proprietary; see LICENSE and NOTICE. Releases up to and including 5.5.6 remain governed by their published Apache-2.0 terms.

ASK Engine is the product. The CLI command is ask. The legacy sourcecode command still works as a deprecated alias (it prints a one-line notice and forwards to ask) and remains the Python/PyPI package name for now. The authoritative version is whatever ask version reports. See docs/PRODUCT_IDENTITY.md.


The problem

Every time an AI coding agent starts a new session, it has to re-parse the repository from scratch. On a large Java/Spring monolith that is thousands of files of parsing per turn, repeated for every question asked about the same unchanged tree. Multiply it by dozens of agent turns per hour, and repo context acquisition becomes a real bottleneck — not just latency, but tokens, compute, and iteration velocity.

ASK Engine solves this with a persistent structural cache keyed on file content hashes. After the first scan, later invocations reuse pre-built context whenever their command can consume the warmed layers. The repo doesn't change? The cache doesn't expire.

Product route: individual commands and packs

ASK Engine keeps individual commands for precise, scriptable questions and adds workflow-shaped packs for users who want one consumable result:

ask pack assessment . --profile prod --output-dir .ask/packs/assessment
ask pack gate . --since origin/main --output-dir .ask/packs/gate
ask pack assessment . --format markdown -o assessment.md
ask pack assessment . --only risk,posture --output-dir .ask/packs/assessment
ask pack gate . --pr 123 --output-dir .ask/packs/gate

For deployment-aware posture evidence, pass the artefacts that describe the environment being assessed:

ask pack assessment . --deployment k8s/deployment-prod.yaml \
  --output-dir .ask/packs/assessment

The gate also renders native CI log annotations without changing its JSON contract:

ask pack gate . --since origin/main --format github-actions
ask pack gate . --since origin/main --format gitlab
ask pack gate . --since origin/main --format sarif -o gate.sarif

pack gate --pr NUMBER uses the local gh CLI to resolve changed files and the exact base commit; the base SHA must already exist locally. It does not fetch or modify the repository. pack assessment --only runs named assessment components and records omissions in the manifest. MCP's get_assessment_pack accepts the same selection as only: list[str] and returns the reproducible CLI command in its mcp projection. SARIF is a bounded export of ASK-owned gate decisions, not a re-emission of third-party findings.

PASS, BLOCK and UNVERIFIED are data decisions. The process exit code is the CI signal; --allow-unverified can change only that exit code, never the reported verdict. Every pack carries a manifest with component invocations, source evidence and content fingerprints.

For agent integrations, ask repo-ir --since <ref> --budget-tokens N bounds the serialized inline answer. If the full graph does not fit, ASK returns its summary view and declares token_budget.coverage: non_coverage; it never silently truncates JSON. For a rerunnable cost comparison, use scripts/context_cost_harness.py with explicit --with-ask and --without-ask command templates. It executes without a shell and publishes a token delta only when both commands resolve and --comparable is declared.

The Product Route is normative: ASK focuses on deterministic evidence for Java/Spring modernization and safe change. Packs compose existing commands; they do not hide or replace them.

For agent integrations, local MCP exposes the same pack evidence through get_assessment_pack and get_change_safety_gate. MCP defaults to a compact projection that preserves the decision and manifest; use the CLI with --output-dir to persist complete component artifacts. See MCP pack evidence.

The cache is not a performance optimization. It is what makes ASK Engine usable as infrastructure rather than a one-off tool.


Proof — measured on real repos

Repo Size Cold scan Cache hit Speedup
Keycloak 7,885 Java files 10.5s 0.6s ~17x
BroadleafCommerce 2,985 Java files 2.7s 0.3s ~9x

These numbers are cache-layer benchmarks, not a promise for every command. Per-symbol queries and compact context benefit most, and inventory commands scale with file count. What a repository-wide analysis costs tracks the build more than the file count: on one 3,342-file monolith, at one commit, spring-audit measured 2,351s on 4.11.0 and 8.4s on 4.18.0 with a byte-identical payload — so ASK publishes measured anchors and the release each was taken on, and never projects a duration for your repository. ask cache model prints both anchors per command, and risk — the one composition still measured in the tens of seconds at that size — is the one to give a budget or a detached run.

With the right command class, ASK Engine becomes constant infrastructure inside agent loops — call the fast/context surfaces before edits and reserve deep compositions for the points where their evidence is worth the runtime.

Large-repo controls. Pass --progress stderr (or --progress file:run.log) for line heartbeats in a non-TTY supervised run — with the file being read so far and an ETA for the stage being measured. ASK_PROGRESS sets the same thing in the environment, and the heartbeat is emitted by the analysis itself, not only by a timer thread, so a CPU-bound stretch is never silent. --jobs N / -j (env ASK_JOBS) sets the worker processes that parse files — default CPU count − 1; parallelism only warms the content-addressed parse cache, so the answer is byte-identical at any value. It does not parallelise the rule pass — measured with metadata.timings on a 2 766-file repository, the CIR build is 88 % of a repository-wide audit's clock and every rule together 8 %, so the flag covers the phase that holds the cost; a warm cache leaves it nothing to parse, so raising it there buys nothing. Long repo-wide/deep runs also write durable records under ~/.sourcecode/runs/<repo-hash>/ by default, not inside the audited repository; set ASK_RUNS_IN_REPO=1 only when repo-local .ask/runs records are intentional. Use ask audit-report --from-risk risk.json to package an existing risk run instead of recomputing it.

A budget is honoured, never a veto. ASK_MAX_ANALYSIS_SECONDS=<seconds> currently bounds the phase-runner commands spring-audit, risk and audit-report; it is not a process-wide timeout for every command. A value below the class floor prints what that class typically needs and runs anyway — refusing to answer is the opposite of this product's doctrine. A run that spends its budget stops on the loop that is spending the time, not only between phases: a rule family cut in flight is published as rules_partially_run with how far it reached, families that never started are named in rules_not_run, _partial names the phases that completed and the ones that did not, and the findings measured before the cut are kept. The answer marks itself where the numbers are — summary.partial, counts_are_floor, counts_basis — and confidence_level is capped at low, because the confidence of the findings that exist says nothing about the family that did not run. Measured on BroadleafCommerce (2 766 Java files): a 4.5s budget stops at 1 408 files and ends at 5.1s. Commands outside that phase-runner set must not be gated on this variable; their budget applicability remains visible in the defect ledger.

Memory is measurable and bounded. Repository-scoped JSON answers publish _meta.memory.peak_rss_mb and the configured ceiling. --agent applies a 1,536 MB ceiling by default; set ASK_MAX_RSS_MB=<megabytes> to override it or ASK_MAX_RSS_MB=0 to disable it explicitly. If the process exceeds the ceiling, ASK refuses the answer with MEMORY_TOO_LARGE, including the observed peak and limit.

Current performance status. Release 5.9.22 retains the shared Canonical IR path used by validation and now passes that same CIR into labelled data-exposure runs; the no-label path remains parse-free. These are implementation properties, not duration promises. It also removes two repeated walks of the same file tree in the detection phase, measured at 1.69× on a 24,073-file monorepo — 54.9 s to 32.5 s cold, with a byte-identical answer. A measurement on one repository and one machine is not a duration promise either. It also avoids repeated monorepo tree walks when optional context and semantic analysis share the same scan.

The root analysis now stops at ASK_MAX_ANALYSIS_SECONDS instead of running past it: a spent budget returns a structured partial result naming the phases that completed and those that did not, and --ci makes a cut run fail the gate with exit 75 (--allow-partial accepts one deliberately). The long-run progress message names the phase it is in and whether that phase has changed, so a slow run is distinguishable from a blocked one.

External audit boundary (2026-09-01). An alternative native-Windows audit rates the 5.9.23 audit-command family 4.9/10, versus 6.6 for 5.9.22. It measured 55 zero-byte exit 0 answers and eight timeouts in 84 runs across spring-audit, verify, risk, Markdown audit-report, migrate-check, and migrate-apply. The release must not be used to gate unattended CI through those commands, nor should ASK_MAX_ANALYSIS_SECONDS be relied on as a recovery path, until native repetition proves the global output and partial-result invariants. The unaffected lightweight CI commands are useful evidence, but do not close this release-wide reliability failure. Findings are tracked in the alternative audit, the earlier external audit, and the defect ledger; engineering-host measurements cannot close native-Windows observations.

The current external audit still records two open availability limits, and they are held open deliberately: audit-report --format markdown under contention, and the root compact flow under strict timeouts on very large monorepos. Neither reproduces on the engineering platform, so neither is closed on measurements taken there. Use ask cache model <repo>, --progress stderr, audit-report --from-risk and JSON/YAML output for supervised runs; consult the current reliability queue before treating a historical timing or bounded flag as a current guarantee.

A post-remediation re-audit of 5.9.18 also found a separate pack gate --since regression on Windows: the git-ref materialization path could resolve to Python 3.10 and fail in tarfile before the stderr-forwarding fix mattered. Release 5.9.19 adds the version-compatible extraction path; native Windows repetition is still required before treating pack gate as production CI evidence.

CI delivery and workspace licensing. migrate-check --format sarif emits ASK-owned migration findings with source locations and provenance; it does not re-emit imported scanner findings. ask auth workspace <repo>... previews the aggregate Java entitlement. --enforce is an opt-in named-buyer pilot that reuses the existing Pro gate; advisory mode remains the default and no billing is performed by the CLI.

auth workspace normalizes its repository arguments before counting. If one path contains another, the parent is counted once and the overlap is published in overlapping_paths; a missing or non-directory path is rejected as structured invalid input rather than treated as an empty repository. This prevents silent entitlement errors in CI and does not change per-repository gates or billing.

Release 5.9.17 also carries the boundary-contract hardening: missing consumer repositories, malformed CVE feeds and unresolved pack gate --since refs fail as structured input errors; duplicate same-commit baselines are never overwritten. That contract is still not enough to make pack gate CI-safe on Windows, because the materialization path can still hit a Python 3.10 tarfile mismatch in mixed environments. posture --diff validates unknown profiles when the repository declares profiles. In endpoints --compact, an empty endpoints list is explicitly marked as an intentional omission, not an empty API; unresolved impact and impact-chain queries exit non-zero, including on repositories without Java sources.

What a warm actually covers. ask cache warm rebuilds the declared root views and their shared structural layers (L1/L2 + the Repository Intelligence Snapshot + the shared Canonical IR). Pass --views compact or --views compact,agent to warm only selected views; without --views, all declared views are warmed. Deeper projections are separate keys and are not covered by either — --full, --env-map and a raised --depth recompute on first use, as do most prepare-context tasks. Measured on a 3,342-file Spring monolith: cache warm 103s → --compact --git-context 1s (hit), but --agent --full --env-map --depth 20 still 171s (miss).

One rule for invalidation, and a table that names every command. Every layer keys on the exact tree state: any change to the analysed files invalidates it, committed or not. Which of your commands a warm helps — the answer, only the shared work, or nothing — is published per command: ask cache model, or docs/CACHE.md.


Install

# Homebrew (macOS / Linux)
brew tap haroundominique/sourcecode && brew install sourcecode

# pip / pipx
pipx install sourcecode        # or: pip install sourcecode

ask version                    # ask 5.9.28 — and, on a build that has aged,
                               # how many releases have probably shipped since

Package vs. command. The install package is named sourcecode in this release (renaming the distribution is a separate, breaking change). Installing it gives you the canonical ask command plus the deprecated sourcecode alias.

Platforms. macOS, Linux and Windows are exercised in CI. The Windows battery runs the full suite on every push, with focused envelope and memory-footprint cases. UTF-8 streams are forced at both console entry points; a successful run writes nothing to stderr (PowerShell 5.1 raises NativeCommandError on any stderr write), and the MCP server strips the BOM PowerShell can put on stdin. For PowerShell, prefer --output <file> over shell redirection when retaining an artefact. A successful CI run is the portability evidence for a release; report a rendering problem with the command, shell and encoding.


Quickstart

Start with these four. In three independent field evaluations they carried most of the measured value, and posture --diff is the one no evaluator found an equivalent for — commercial or open source.

# What does each profile set ACTUALLY wire — and what changes between them?
# Resolves conditional beans and the filter chain, then diffs effective endpoint access.
ask posture /path/to/repo --diff dev:prod

# Every REST endpoint with its effective path (context-path + servlet path resolved),
# its inferred security policy and a confidence per endpoint.
ask endpoints /path/to/repo

# Spring semantic audit: transactional anomalies (private @Transactional = silent
# CGLIB no-op), security surface, request-body validation.
ask spring-audit /path/to/repo

# Spring Boot 2→3 readiness plus Java LTS/licensing inventory.
ask migrate-check /path/to/repo --compact
# Add --target-jdk 25 to make the LTS route explicit.

Then the three that finish the sentence the four above start. A profile-set answer stays conditional until you know which set the deployment starts with, a gate nobody can populate is a gate nobody runs, and a defect ranked without its reach is a linter note:

# Which profile set ACTUALLY runs? Reads every artefact that can set it — build,
# descriptors, Dockerfile, Compose, Kubernetes, launch scripts — with file:line, and
# says NOT DECIDED IN THIS REPOSITORY when nothing in the tree decides it. Then ranks
# every admissible set by what it leaves reachable without authentication.
ask posture /path/to/repo --resolve-environments

# Derive the contracts this repository already satisfies, execute each one before
# writing it, and populate .ask/contracts.yml from the measurement instead of by hand.
ask verify /path/to/repo --init

# Same derivation under a read-only constraint: prints what it would declare and
# writes nothing — the form an audit of somebody else's repository can run.
ask verify /path/to/repo --init --dry-run

# What each defect actually costs once reach, access, write effect and the shape of
# the input path are in it — ordered, every factor traceable to the command that owns it.
ask risk /path/to/repo

And the three that answer questions this repository does not contain the answer to. The profile set is decided by a deployment artefact, the consumers are other repositories, and since when is a fact about history — each one is a join of things already measured, and each one leaves the previous answer untouched when it cannot decide:

# The artefact that decides the profile set — Kubernetes manifest, compose file, WebLogic
# deployment plan, Dockerfile, dotenv, launch script. Every answer is then given under the
# set it names, with the file:line that decided it. An artefact that decides nothing (a
# placeholder, two artefacts that disagree) leaves the repository's own verdict as it was.
ask posture /path/to/repo --profile-from k8s/deployment-prod.yaml

# Of the routes a readable rule leaves open: which ones a consumer actually calls (work),
# and which ones nobody calls (surface to delete instead of guard). Reads TypeScript/JS and
# Java consumers, only where the verb and the path are written at the call site.
ask endpoints /path/to/repo --consumer ../web-client --consumer ../partner-api

# Since when. Walks the commit series, runs the analyses that already ship on a read-only
# materialisation of each sampled tree, and publishes where a number MOVED — with the commit
# it was observed at and the window it could have happened in.
ask timeline /path/to/repo --since v1.0 --watch posture,data-exposure

Then the everyday loop:

# High-signal structural summary — warm cache ~0.3s, cold 2–10s
ask --compact

# Blast radius: what breaks if this class changes?  (target the INTERFACE, not the Impl)
ask impact OrderService /path/to/repo

# Onboard to an unfamiliar codebase
ask onboard /path/to/repo

# PR review: risk, test gaps, changed modules
ask review-pr /path/to/repo --since main

# CI gate on NEW violations only, instead of on pre-existing debt
ask verify /path/to/repo --init               # derive the contracts, don't hand-write them
ask verify /path/to/repo --capture-baseline   # accept today's debt, once
ask verify /path/to/repo                      # then: only new violations block

And the loop that closes. Finding, question and change each had a command; what they did not have was a way through. These are the joins, and each refuses rather than guess:

# Which advisories a route can actually REACH — not which are on the classpath.
# Reads a LOCAL feed; no network is taken, so a CI gate can never pass because a
# fetch timed out. Nothing answers "not reachable": absence of a resolved edge is
# not absence of use, and the payload says so.
ask cve /path/to/repo --feed ./osv-maven.json --reachable-only

# Ask in your own words. It SELECTS one of retrieve's 29 typed queries and prints
# it (--run executes it); it never invents an answer, and a question that fits two
# intents too closely is refused with both named.
ask intent "what breaks if I change OrderService?"

# Finding → recipe → apply in a dedicated worktree → verify. Dry by default. Most
# findings are not mechanical, and the plan says which and why.
ask remediate /path/to/repo

# One verdict for THIS diff, not for the repository. A changed file that maps to no
# class caps the verdict at UNKNOWN — a partial blast radius is not a small one —
# and UNKNOWN fails every gate.
git diff --name-only main | ask pr-risk /path/to/repo --files - --fail-on block

# What opened up since the last capture, on the axis posture --diff does not have.
ask drift /path/to/repo --profile prod --capture   # record today
ask drift /path/to/repo --profile prod             # then: what moved

# While you edit: one answer per save, against the warm index.
ask watch /path/to/repo --once

# Show me the architecture, don't hand me JSON to render.
ask export /path/to/repo --c4 --render mermaid

Adopting a gate on a real codebase. Nobody hand-writes contracts for a 3 000-file monolith, so ask verify --init derives the ones the repository satisfies today and executes each before writing it — init followed by verify passes by construction. A repository that starts declaring contracts already violates them somewhere; ask verify is baseline-relative by default (--fail-on new) so the gate survives contact with reality instead of being switched off on day one. A pipeline wired before the contracts exist exits 2 (unverified, with unverified_reason naming which state it is); --allow-unverified exits 0 while the verdict stays unverified — the declared form of || true, and violations still block. ask baseline capture|diff|trend is a different thing: versioned architectural metrics over time, for trend reporting rather than blocking.

Full command reference: docs/USER_GUIDE.md · posture in depth: docs/posture.md.


Capabilities

Everything is computed from one cached structural model. Seven groups:

1 · Structural Context

Bounded, noise-free repo context designed to drop straight into an agent's context window. ask --compact · ask --agent · ask onboard · ask cold-start → reference

2 · Impact Analysis

Blast radius from a class or interface — reverse dependencies, through Spring DI, to the HTTP endpoints a change reaches. ask impact · ask impact-chain (blast radius; --with-findings for TX/SEC audit findings) · ask pr-impact · ask pr-risk (one verdict for the diff — UNKNOWN when the blast radius has a hole, and UNKNOWN fails the gate) → reference

3 · Architecture Intelligence

The system map: module graph, dependency views, REST surface, per-class summaries, and a symbol-level IR for downstream tooling. ask export (--c4 --render mermaid|svg draws it) · ask repo-ir · ask endpoints · ask explain · ask timeline (experimental — the same views over the commit series: when a number moved, and in which window) → reference

4 · Migration & Modernization

Is this codebase ready to upgrade? Per-dimension readiness (Jakarta / Spring Boot / JDK / Hibernate), located blockers, an effort estimate, and — with --blast-radius — the endpoints whose call path runs through each blocker, so the re-test plan is ordered by regression scope. ask migrate-check · ask modernize · ask remediate (finding → recipe → apply → verify; dry by default, and an apply it could not verify is never reported as applied) → migrate-check reference · MODERNIZATION.md

5 · Spring Analysis

Deterministic Spring semantics: transactional anomalies (e.g. @Transactional on a private method = silent CGLIB no-op), security surface, request-body validation. ask spring-audit · ask validation · ask cve (dependency advisories gated on whether a route can reach the vulnerable package — from a local feed, with no network taken) → reference

5b · Runtime Posture (experimental — and the most differentiated thing here)

What a profile set actually wires: which conditional beans register, which do not, and which conditions could not be decided at all — then the effective endpoint access that follows from the filter chain. --diff answers the question nobody else answers in one command: what changes between dev and prod, across every endpoint at once. ask posture · ask posture --diff dev:prod · ask posture --property k=v · ask drift (the same comparison across time — what opened up since the last capture) → posture.md

--diff-ref makes it a gate instead of a report. --diff moves the profile set; --diff-ref origin/main:HEAD (or --since origin/main, which compares a ref with the working tree) moves the tree under one profile set and answers did this branch open an endpoint. --fail-on opened exits 1 when it did. Both refs are read with git archive — nothing is written to the repository. The comparison is keyed on the request (METHOD path), counts requests only one side serves, and never reports a rule that disappeared as protection gained. ask posture . --since origin/main --fail-on opened

--resolve-environments carries it past the edge of the repository. Every answer above is conditional on a profile set, and which set runs is decided by the deployment. This flag reads every artefact in the tree that can set spring.profiles.active — Maven/Gradle, web.xml, Dockerfile, Compose, Kubernetes, launch scripts — with file:line, and returns decided_in_repository, artefacts_disagree (two deployments, never resolved by picking one) or NOT DECIDED IN THIS REPOSITORY. Then it resolves every admissible set over one parse and publishes the worst. A field audit closed those five hops by hand with grep before the flag existed. ask posture . --resolve-environments

--profile-from closes the loop. --resolve-environments reads what the repository says; the artefact that actually decides the profile set usually lives outside it. Name it — Kubernetes manifest, compose file, WebLogic deployment plan, Dockerfile, dotenv, launch script — and every answer is given under the set it sets, with the file:line that decided it. Undecidable-first, so pointing it at the wrong file costs nothing: a placeholder, an entry with no value, or two artefacts that disagree decide nothing and leave the repository's own verdict byte-for-byte as it was. The process environment still outranks the file, and the payload says so. ask posture . --profile-from k8s/deployment-prod.yaml

Unresolved is a first-class outcome: a condition the resolver cannot decide is reported as a hole with the condition named, never folded into active or inactive. A posture answer that guesses is a confident security falsehood — the worst failure mode this tool has.

5c · Composed Risk

Every command above answers one axis, and a reader composes them by hand. ask risk does the join over the endpoint and symbol ids these commands already share with each other: severity_effective = defect_severity × reachability × auth_verdict × write_effect × query_construction × input_constraints. The product of the published factors is the published score — decomposable to the six figures and the authority behind each — and an axis this build cannot measure is unknown, weighted 1.0 and named in blind_axes rather than silently treated as safe. Measured on a field case: a defect both spring-audit and impact-chain called medium composes to high (8.06) once reachable unauthenticated and writes to the database are in it. The last two factors describe the input path: a query assembled by concatenation, a bounded HTTP-input-to-query-sink path when ASK can prove one, and a route accepting a body with no declared constraint. The sink family a MyBatis codebase actually uses is covered too: an annotated HTTP input reaching a statement that splices it into the SQL with ${...} is a three-state verdict — reaches (with the trace), does_not_reach (stated only where the call sites were found) or undecidable — and only the first moves the factor. The census is published beside the rows, so the multiplier is auditable rather than asserted. General taint remains NC-001 and is published in the payload's own non_coverage block. ask risk . · ask risk . --min-band high · ask risk . --limit 10 → reference

6 · Developer Workflows

The everyday loop: diff-based PR review, symptom-driven bug triage, and delta context for continuous agent runs. ask review-pr · ask fix-bug · ask prepare-context · ask watch (one answer per save, against a warm index) · ask intent "<question>" (a plain-language question resolved to a typed query — it selects one, it never invents an answer) → reference

7 · Utilities

ask rename-class (word-boundary Java rename) · ask chunk-file (split large files for agents) · ask cache (status / warm / model / clear / freshness) · ask self-audit (does the installed build's own registry agree with itself?)

rename-class migration note: current releases require the explicit form ask rename-class <repo> --from OldName --to NewName. Older positional forms are not accepted; use --dry-run first when migrating scripts. → reference


Command tiers

A tier says what an output is worth relying on — it is a stability promise, not a value ranking, and not the pricing tier (Free/Pro gates repository size, never capability). posture is the most differentiated command in the product and it is experimental: both are true, and they are two different facts.

Tier Promise Commands
core contract stable within a major — safe to gate CI on endpoints · spring-audit · migrate-check · impact · impact-chain · pr-impact · verify
supported maintained; fields are added, never removed without a major every command not named in another row
experimental shape may change in a minor — do not gate CI on it enrich · archetype · timeline
parked kept working, no longer developed retrieve

The same table is printed by ask --help, and both are generated from one authority (cli.COMMAND_TIERS) — the battery fails if a command is in no tier, or if this file drifts from it.


Every command, in one table

ask --help shows a short header; this is the full surface. If you only read one row, read posture.

Command Tier Answers Note
posture supported which beans a profile set wires, and how effective endpoint access differs between two sets the most differentiated capability here. --resolve-environments says which set the repository decides; --profile-from <file> reads the artefact that actually decides it (Kubernetes manifest, compose file, deployment plan, Dockerfile, dotenv) and answers under that set, with the file:line — deciding nothing leaves the verdict untouched
risk supported what each defect actually costs, once reach, access, write effect and the shape of the input path are in it defect_severity × reachability × auth_verdict × write_effect × query_construction × input_constraints; every factor names its authority; the query_construction factor covers MyBatis ${} splicing with a three-state verdict (reaches / does_not_reach / undecidable) and publishes the census; --table --rule SEC-008 --band high --top-n 20 gives audit triage without jq
enrich experimental another scanner's SARIF findings, ranked by what this repository does with them --sarif <log>; same composition as risk, with --table --rule <id> --band high --top-n 20 for triage
audit-report supported human audit bundle over existing risk + posture evidence, optionally signed includes evidence_manifest claim provenance; --format markdown; --sign-key <file> signs canonical JSON with HMAC-SHA256; --pack ens adds a technical ENS control matrix
audit-verify supported offline verification of a signed audit-report bundle recomputes the canonical payload and HMAC-SHA256; returns valid: true/false and a CI-friendly exit code without re-running the audit
migrate-recipe supported the migration report as the OpenRewrite recipe that applies it only recipes a finding named; the manual remainder published beside them; writes nothing without --write, and never a runnable command for an empty recipe list
migrate-apply supported apply a measured recipe without touching the main tree Maven and Gradle executors; plan by default; --write requires clean Git, pinned version and isolated worktree; no automatic commit or merge
data-exposure supported which routes can carry the data you labelled, and who reaches them labels declared in sourcecode.config.json — never inferred from a name; signature and call_reach evidence published apart, field-level flow out of scope (NC-008). With nothing declared, ask data-exposure /path/to/repo answers answered: false and hands back the file, the key and an example to declare — it never reports zero exposed routes
data-exposure --init supported generate review-only label candidates writes only .ask/data-label-candidates-v1.json with status: proposed_only; it never activates labels
endpoints core every REST endpoint, effective path, security policy, confidence Spring MVC + JAX-RS (~65 % recall on JAX-RS sub-resource locators). --compact answers the exposure census without the rows; --servlets lists the servlet-mounted surface as its own population; --client-usage says which routes the TS/JS client in this repository actually calls; --consumer <repo> (repeatable) joins the routes against consumers in other repositories — TypeScript/JS and Java — and turns the census into a surface-reduction plan: open and called (fix now), open and called by nobody (delete rather than guard), and calls this server serves no route for
spring-audit core transactional anomalies + security configuration/exposure + validation gaps --ci, -f github-comment, or -f github-actions for native CI annotations; --table --rule SEC-008 --top-n 20 for human-scale review. Every run inventories its own rules — rules_run, rules_not_run, rules_partially_run, rules_run_count/rules_total — so "all of them" is a fact, not an assumption
migrate-check core Boot 2→3 readiness + Java LTS/licensing inventory: located blockers, per-dimension score, effort, detected Java 8/11/17/21/25 evidence and explicit licensing-review signals --target-jdk 25 sets the target LTS route; --blast-radius orders the re-test plan; --format github-actions emits a stable CI annotation; --format sarif emits located ASK-owned findings; --table --rule MIG-001 --band critical --top-n 20 for blocker triage
impact / impact-chain core blast radius of a change, to the endpoints it reaches target the interface, not the Impl
pr-impact core the same, scoped to a PR diff local git diff HEAD, --since REF, explicit --files, or opt-in --pr NUMBER; --format github-actions emits CI annotations; --fail-on gates
verify core does the repo satisfy its declared contracts, relative to a baseline .ask/contracts.yml; --format github-actions emits a native CI annotation while preserving exit 0/1/2. .ask/waivers.yml adjudicates a finding as not a defect here (stable id + required reason, optional expiry) so a reviewed row stops holding the gate red — a baseline records accepted debt, a waiver says it was never a defect
verify-edit supported did the working-tree edits change runtime behaviour semantic diff gate for the edit loop
--compact / --agent — bounded structural context for an agent flags of the root command, not commands: not tiered
onboard / explain / cold-start supported orientation in an unfamiliar repo; per-class summary; bootstrap snapshot onboard publishes population, population_unit and population_total for its source-file universe
export / repo-ir / schema supported tool-agnostic views (C4, module graph, integrations); symbol-level IR; published JSON Schemas export --c4 --render mermaid|svg draws the model instead of only emitting it; repo-ir --since REF --budget-tokens N provides bounded, deterministic agent context
modernize supported coupling hubs, cycles, dead zones, refactor candidates
review-pr / fix-bug / prepare-context supported diff review, symptom triage, task-shaped context
plan / compare / delta / contract-diff supported what to review for a change; candidates by measured cost; outcome of a change; public-contract break no verdicts, measured cost only
validation supported request-body validation coverage and gaps
baseline capture|diff|trend|attest supported versioned architectural metrics over time, findings history and a bounded read-only evidence attestation (baseline-attestation-v1) with explicit comparability and non-coverage trend reporting and evidence continuity, not gating or legal compliance. Baselines land in .ask/baselines inside the repository or an external --dir; automate capture with baseline-ci.yml
cve supported which dependency advisories a route can actually reach — not which are on the classpath reads a local OSV feed (--feed) and optional local VEX statements (--vex); VEX is matched exactly and annotates accepted_by_vex without changing reachability; takes no network at analysis time
intent supported a plain-language question, resolved to the typed retrieve query that answers it ask intent "what breaks if I change OrderService?". A scored lexical match against a declared vocabulary — no model, no generation — so it resolves identically on every machine. It selects a query and prints it; --run executes it. A question fitting two intents too closely is refused with both named, because a well-formed answer to a question you did not ask is invisible once printed
remediate supported the loop from a finding to a verified change audit → recipe → apply in a dedicated worktree → verify-edit. Dry by default. Most findings are not mechanical and the plan says which and why; an apply that could not be verified reports unverified, never applied
pr-risk supported one verdict for this diff — does the change make things worse? pack gate answers about the repository; this answers about the change. Joins pr-impact reach, endpoint access, the shared risk model and CODEOWNERS. --since differences route inventories so new_endpoints is a fact rather than a guess. A changed file that maps to no class caps the verdict at UNKNOWN, which fails every gate — a partial blast radius is not a small one
drift supported what changed in the effective access, and when --capture records; the default compares against the last record; --against compares two profile sets. One arithmetic for both axes, so the time answer and the environment answer cannot disagree. newly_unmatched and newly_matched are separate buckets, and a removed route is never reported as having become safe
watch supported what each save affected, against a warm index one JSON line per tick. --once is the pre-commit shape; --ticks/--for bound the loop. A failed analysis is an error tick, never an empty change list; a file added since the warm is unresolved, not unreachable
self-audit supported whether the installed build's own registries agree with each other a battery proves the source tree consistent while a user runs a wheel. Checks the cache model, format contract, schema registry and output affordances. Says plainly what it cannot check: the semantic engine analyses Java and this build is Python, so those figures are declared absent rather than reported as zeros
retrieve parked typed knowledge queries over the model symbol-oriented queries accept --target/-t; domain aliases such as --module/-m, --subsystem/-s and --endpoint/-e remain supported
timeline experimental since when a number moved, and in which commit window walks the commit series and re-runs the shipped analyses (posture, data-exposure, endpoints, spring-audit) on a read-only materialisation of each sampled tree; publishes transitions, not a per-commit dump. A sample that could not be analysed is null with a reason, never 0, and a transition under sampling carries the window it could have happened in
regress supported what moved between two payloads of the same command, and which declaration accounts for it attributes each delta to a declaration the answers carry (test_source_excluded, symbols_excluded, coverage.gaps, *_cap, waivers); a delta nothing explains is unattributed. Refuses the comparison when cache_layers, base_env or the analyzer fingerprint differ
explain-endpoint supported the derivation behind one route's verdict six steps — match, declaration, handler, chain, profiles, verdict — each naming the authority that produced it and the file it can be checked against; a step that could not be derived is undetermined with the reason, never absent
selftest supported this product's own defect ledger, run against your repository each ledger row's acceptance criterion as an executable assertion, with the subject (repository, size, platform, entry point) beside every verdict; a row whose precondition the repository does not meet is not_applicable with the reason, never a pass
archetype experimental evidence-based architectural archetype publishes the scanned source-file population explicitly
rename-class / chunk-file supported word-boundary Java rename; split a large file for an agent
cache status|warm|model|clear · auth · telemetry · mcp · config · version supported housekeeping cache model [path] explains what a warm buys per command; activate too

What it does — and doesn't

ASK Engine reduces exploration cost. It accelerates context acquisition and computes blast radius; it does not replace reading code — it reduces how often an agent needs to. All signals are static and deterministic (annotations, import graph, file structure) — no runtime analysis, no LLM guessing.

Honest limits worth knowing before you rely on it:

  • impact on an implementation class (OrderServiceImpl) returns 0 callers in Spring Boot — callers inject the interface. Always target the interface.
  • no_security_signal on an endpoint means no recognized method-level annotation, not "unsecured" — Spring Security filter chains and custom authorization annotations show as no_security_signal unless taught via config (below).
  • spring-audit / impact-chain are Java/Spring only; non-Java repos return spring_detected: false.
  • Event topology (--type events) resolves Spring ApplicationEvent / @EventListener chains only — not Kafka/RabbitMQ/Redis routes.
  • Architecture classification is tuned for Spring MVC layered apps; SPI/plugin models (e.g. Quarkus extensions) may be misclassified. JAX-RS subresource-locator endpoint recall is ~65%.
  • Self-invocation @Transactional bypass (same-class call skipping the proxy) is not detected.

What the security section is, and what it does not answer

What it reads: the security configuration and exposure of a repository — which rules the request chain declares, which endpoints they leave open, which controls are present but disabled, and which custom gates can be bypassed, each with the file and line that says so.

What it is not: a vulnerability scanner. No value flows through a program here, so an injection, a deserialization sink or a logic flaw inside a method body is not looked for, and its absence from the report is not evidence (NC-001, below).

Where it is strongest: given a defect somebody else found — a scanner finding, a line from a review — ask impact <symbol> and ask risk quantify what it reaches: the endpoints, the transactional boundaries and the modules downstream of it, with the confidence of each hop. That is the question a taint scanner does not answer.

Published because a product that states its limits is not compared on breadth — it is compared on depth. Each row is emitted in the payload too (non_coverage), so an agent reading JSON sees the same boundary a buyer reads here.

Not covered Why What answers it
General request-input-to-sink taint analysis. ask risk includes two bounded slices for annotated HTTP parameters and positional calls in repository Java sources: known query sinks, and MyBatis statements that splice a value into their SQL. “Known” is a published list — risk prints it as query_sink_vocabulary, with the calls it deliberately leaves out and why — so a concatenation into a call outside that list is not a miss to be discovered, it is a stated boundary. Anything broader needs value flow through a program, which is a different analysis with a different failure mode: an unsound one produces confident findings that are wrong, and every claim here is meant to be checkable against the line that produced it. A dataflow scanner (Semgrep, CodeQL) for complete taint. What this product adds on top is reachability and, for the two bounded slices, whether an annotated HTTP input reaches a known concatenated query sink or a spliced SQL statement — the latter with a three-state verdict that says undecidable rather than clearing a route it could not follow.
Secrets outside Java, Spring configuration and the deployment descriptors — a Helm value, a CI variable file, a shell script. The file population this analyzer reads is the Java source, the Spring configuration convention and the descriptors it already parses to resolve an environment. A secret elsewhere is not missed by a weak rule; it is outside the set of files anything here opens. Narrowed by CL-10: a credential stored in web.xml or a Spring XML context IS reported (SEC-007), because those files were already being read. A dedicated secret scanner over the whole tree (gitleaks, trufflehog).
Filter-chain order and per-filter URL patterns — the presence of a custom filter is structural only. Which filter runs first is decided by bean ordering this analyzer does not resolve. Where two active configurations both match a request, the answer published is undecided rather than a guess. ask posture --profile <set> states per endpoint what the readable rules decide and what they leave undecided.
Discovering vulnerabilities, and shipping the database that lists them — no embedded CVE feed, no network lookup at analysis time. Maintaining a vulnerability feed is a different product with a different update cadence, and a stale embedded database is worse than no database because it reads as a clean bill of health. That boundary is unchanged. What IS built is the half this project can be responsible for: ask cve --feed <osv.json> takes a feed you supply and pin, and answers whether a route can actually REACH the vulnerable package, using the same blast radius as impact-chain. The feed's own staleness travels with the answer, an unreadable feed is a refusal rather than a clean scan, and nothing there answers "not reachable". A dependency scanner (Trivy, OWASP Dependency-Check, an OSV export) supplies the advisories; ask cve says which of them anything actually reaches.

Two more boundaries worth stating in the same voice:

Not covered Why What answers it
Applying a migration to the main tree. ASK never edits the main tree. The explicit migrate-apply --write path requires a clean Git tree, a pinned OpenRewrite version, and an isolated branch/worktree; it runs migrate-check afterwards, and never commits or merges. OpenRewrite via ask migrate-apply . --write --rewrite-version X.Y.Z; add --compile for an optional timed build, then review the retained worktree before merging.

migrate-check does not cover Applying a migration — nothing here edits source. | What the process environment sets at start-up — the profile set, properties and secrets a container is given. | Nothing in a repository can observe the environment of a process that has not started. A value read from a file here is the default the repository ships, never a guarantee of what runs. | ask posture --resolve-environments reads every artefact in the repository that names the profile set, says when none of them decides it, and ranks the admissible sets by what each leaves open. --profile-from <file> goes one step further and reads the deployment artefact itself, which is where that decision is actually written — still a file, so the process environment still outranks it, and the payload says so. |

And one about the endpoint surface itself:

Not covered Why What answers it
HTTP surface that is not a Spring handler mapping — a servlet declared in web.xml or registered as a ServletRegistrationBean, a container-level mapping, a static console mounted by a library. The endpoint population is projected from the Spring route model: one entry per handler mapping. A servlet is reachable over HTTP and is not in that model, so it is absent from endpoints, from the access verdicts derived from it, and from every ratio keyed on the total. Merging a second population into that count would move a published figure and every ratio with it, so the population is declared before it is widened. Read the deployment descriptors for <servlet-mapping> entries and the Spring configuration for ServletRegistrationBean beans. Field evaluation #9 found a monitoring console mounted this way, behind a credential ask spring-audit did report (SEC-007) at a path nothing here listed.

And one about labelled data:

Not covered Why What answers it
Whether a labelled member actually leaves the process on a given route — field-level dataflow through mappers, DTOs, serializers and projections. Exposure here is measured at TYPE granularity over the same call reach every other command walks: a route reaches the labelled type, or its signature names it. Whether the mapping in between keeps the labelled member is a dataflow question, and answering it by approximation would put a confident no on a route that does leak. So call_reach is published as a supremum and says so. Read the mapping on the routes this answer ranks first — they are the ones worth a human — and label the DTO too if it carries the member, which makes the route signature instead of call_reach.

And one about who calls a route:

Not covered Why What answers it
Whether a route is called from outside this repository — another service, a mobile app, a partner, a cron job, or a client whose URL is assembled at run time. The join reads the TypeScript/JavaScript checked in beside the server and only the call shapes whose verb and path are written at the call site. That is a floor on who calls a route and can never be a ceiling: the repository cannot observe consumers it does not contain. So a route with no call site here is published as a candidate for deletion, never as dead API. Access logs or an API gateway answer who really calls a route. The opposite direction is decisive without them: a client call matching no route is a request this repository's own front end makes and its server does not serve.

And one about blast radius:

Not covered Why What answers it
The reach of a component the container invokes rather than the code — a security filter chain, an around-advice aspect, a @ControllerAdvice, a bean resolved through the interface it implements. Blast radius here is projected over the call graph: who calls the changed symbol, and which routes reach those callers. Nothing in the repository calls a container-wired component, so its measured call-graph fan-in is ~0 and every figure derived from it — affected endpoints, direct callers, rollback surface — reads as no impact. The fan-in figure is correct; using it as a risk proxy on this population is not. Publishing that as a low verdict would be a confident zero, which is the one thing this product does not do. Such a change is flagged in analysis_warnings and its verdict is floored, never rated on fan-in. The reach itself is measured elsewhere and was there all along: ask endpoints resolves a gate annotation to the routes carrying it, ask explain <class> prints the request chain a configuration declares with its source line, and ask posture --profile <set> states what each profile leaves open. Projecting those into the blast radius (pointcut → routes, matcher → routes) is a measurement this command does not yet make.
A bean reached from a template rather than from code — a Thymeleaf or JSP expression that resolves a bean by name (${@blExploitProtectionService.getCsrfTokenParameter()}) and invokes a method on it. Every reacher this blast radius models is a typed edge or a structural fact recovered from Java: a call, an injection, a container extension point, a string literal inside a reflective lookup. A template is none of those — it is not compiled against the bean, and the reference lives in a file this analysis does not parse. So a component invoked only from a template has a measured fan-in of ~0 and, unlike every other blind spot here, that silence was published without a label: the field found blind_spots: [] on a service two templates call by name. The miss is ordinary; presenting it as an empty result is the defect (E-31). A SpEL bean reference in a template is fixed, published syntax (@beanName inside ${...}), so a text search for the bean's name across .html/.jsp answers it today: grep -rn '@<beanName>' src/main/resources. Admitting it as a fourth reacher would be evidence-shaped for the same reason — the reference is a literal naming a bean this repository declares — and it is not modelled yet, which is what this row states rather than implies.

And one about request-body validation:

Not covered Why What answers it
Programmatic Spring request-body validation wired with org.springframework.validation.Validator or @InitBinder. This surface reads declared bean-validation constraints recovered from OpenAPI or DTO annotations. A validator registered in controller code can enforce body rules without any declarative constraint on the payload, so treating the result as fully verified would overstate what the declared-constraint scan proves. @InitBinder / setValidator(...) wiring, or a Spring Validator implementation, which this surface reports only as a coverage boundary. validation still shows the declared rules; the programmatic validator remains outside that model.

The one row above with a remedy in this build: ask endpoints /path/to/repo --servlets lists the servlet-mounted HTTP surface as a population of its own — web.xml mappings and ServletRegistrationBean registrations, with the file that declares each — and never merges it into endpoints.total. Measured: openmrs-core 7 patterns, alfresco-community-repo 11, including /api/* served by a WebScript servlet.

Positioning. Until an executor ships, this is the diagnosis layer: it measures what must change, what each change reaches, and what a gate should block — and it removes none of it. Field evaluation scored it 7/10 as a report generator and 5.5/10 as a development tool, and that gap is the honest description, not a defect to argue with. migrate-check publishes the OpenRewrite recipe each finding carries so the executor that does apply changes has its input.

Java LTS/licensing inventory. migrate-check emits java_lts_inventory beside the migration scores. It reads Maven/Gradle, local runtime hints and container files for Java 8/11/17/21/25 evidence, reports target-LTS blockers with --target-jdk, and marks explicit Oracle JDK evidence as licensing_review_needed. This is inventory evidence, not legal advice.

Claim provenance ledger. JSON outputs from risk, enrich, migrate-check, audit-report and prepare-context include evidence_manifest: stable claim IDs mapped to source paths/lines, command inputs, ASK version, git HEAD and freshness metadata. The manifest indexes claims already in the payload; it does not add analysis or certify compliance.


Pricing

🎉 Early-adoption: Pro is currently unlocked for everyone. Every install runs with full Pro entitlements — no size gate, no key. The tiers below describe the model the paywall will return to later.

What that means concretely. Ask the product: ask auth status answers in one block — entitlement (what runs today), source (why — a licence, the unlock, or the free tier), authenticated (whether a credential exists, which is a separate fact) and when_it_changes (what you lose when that source stops applying). A fresh install reads entitlement: pro, source: early_adoption_unlock, authenticated: false — unauthenticated and entitled, stated as two facts instead of one contradiction. When the unlock ends, gating returns by repo size and automation, never by command: posture, endpoints, spring-audit and migrate-check stay in the base tier at full output. Nothing you can run today becomes a paid-only command tomorrow.

Gating is by repo size and automation — never by command. Every command runs at full power on Free for small and mid-size repos; you upgrade when the work gets bigger or automated.

Free — €0 Pro — €19/mo · €190/yr per dev
Repo size ≤ 500 Java source files > 500 Java files (enterprise monoliths)
Commands All of them, full output Same commands, unlocked at scale
impact / fix-bug / review-pr / modernize ✅ full on small repos ✅ full on large repos (Free gets a capped preview)
prepare-context delta 30 free runs/repo unlimited — CI/CD automation
MCP local server, offline, no data egress ✅ ✅

Non-Java repos are free at any size — the size limit counts Java source files only. ASK Engine monetises enterprise Java monoliths. Activate with ask activate <key>. Full breakdown: docs/PRODUCT_TIERS.md.

The future commercial direction is staged rather than an immediate product restriction: free adoption, self-serve scale, B2B infrastructure licensing and a generated public trust projection. See the monetization review.


Configuration & privacy

ask config              # version, config file path, telemetry status
ask config /repo        # + the repository's own sourcecode.config.json:
                        #   data labels, custom security annotations,
                        #   and any declaration that could not be used
ask telemetry enable    # ensure anonymous telemetry is enabled

Anonymous telemetry is ON by default. It collects version, OS, commands, flags, duration, repo-size range, and errors: no source code, paths, secrets, or output. Turn it off with ask telemetry disable, export SOURCECODE_TELEMETRY=0, or DO_NOT_TRACK=1.

Auditing someone else's code — regulated, client-owned or public-sector? Set SOURCECODE_TELEMETRY=0 before the run. The setting is explicit, local and honored before any event is sent.

A question is not a write — --no-write / ASK_READONLY=1. One contract over every command: nothing is created inside the analysed repository, and a command that cannot answer without writing says so instead of writing. A refusal is never silent — each one names the path that was not created, on stderr. The scope is the tree you pointed at; the shared caches under ~/.sourcecode and an --output path elsewhere on the machine are not refused, because refusing them would make the mode unusable without making it safer.

Most commands read only, and the few that create anything inside the repository do it under .ask/ and only behind an explicit flag (baseline, migrate-check --history, verify --update-baseline, verify-edit --install-hook, and .ask/runs when ASK_RUNS_IN_REPO=1). ask --help prints that list in full, generated from the one authority the battery checks — a write seam added without a row there fails the suite.

ask spring-audit /path/to/client-repo --no-write -o audit.json

Custom security annotations. Teach endpoints, spring-audit, and explain about project-specific authorization annotations via an optional sourcecode.config.json at the repo root (otherwise they report policy: "none_detected"):

{
  "customSecurityAnnotations": [
    { "fullyQualifiedName": "com.example.security.CustomSecurityAnnotation", "shortName": "CustomSecurityAnnotation" }
  ]
}

Matching endpoints report policy: "custom" and drop out of the no_security_signal count.


Documentation

  • Product Route — individual commands, packs, evidence contract and boundaries
Doc What it covers
USER_GUIDE.md Full command reference, flags, output schema, workflows
contracts.md Declare invariants in .ask/contracts.yml (or derive them with ask verify --init), enforce them in the edit loop and in CI — and adjudicate a finding as not a defect here in .ask/waivers.yml
baseline-ci.yml Capture an architectural baseline per release, so the series exists when you want to read it
posture.md What a profile set actually wires — down to which endpoints its filter chain permits — and what could not be decided
migrate-check.md Migration rule catalogue (MIG-001..043) + Hibernate stratification
MODERNIZATION.md The modernization product: assess → understand → plan → execute
PRODUCT_TIERS.md Free vs Pro, pricing model
DEMO-5MIN.md A reproducible 5-minute demo
MANUAL-USUARIO.md Guía de usuario en español
CACHE.md What cache warm stores, what it does not, and how cache invalidation works
PRODUCT_IDENTITY.md ask (command) vs sourcecode (package/alias)
privacy.md Telemetry and data-handling policy
DEFECT-LEDGER.md Every defect found in the field, its class, and which release closed it — published on purpose
AUDIT-2026-08-26-EXTERNAL-5.8.32.md The most recent external review, its reproduced and unreproduced findings, and the feature intake it opened
spec/envelope-v1.md The output format as an open specification — provenance, a named unit, a stated basis, declared non-coverage. Implementable by tools that are not this one; the field table is generated from the schema ask schema envelope-v1 prints

Metadata

Release files for sourcecode 5.9.28

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for sourcecode 5.9.28
File Size Uploaded Provenance Actions
sourcecode-5.9.28.tar.gz 3.2 MB Without provenance Details for sourcecode-5.9.28.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for sourcecode 5.9.28
File Interpreter ABI Platform Actions
sourcecode-5.9.28-py3-none-any.whl Python 3 none any Details for sourcecode-5.9.28-py3-none-any.whl

Total release size: 5.7 MB

Release files / sourcecode-5.9.28.tar.gz

Download URL sourcecode-5.9.28.tar.gz
Size 3.2 MB
Tags Source
SHA-256 checksum
How to use checksums
adc2950bc58277ed5361ca569b70568773a9f1381b99d6dd6b362d9b5769ff4e
BLAKE2b-256 checksum
How to use checksums
3f46374ebe10ddd0dfaf70ff6c7a1902e01d1d335dae4adcfe4c3489e0b5e3b3
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.2.0 CPython/3.14.6

Release files / sourcecode-5.9.28-py3-none-any.whl

Download URL sourcecode-5.9.28-py3-none-any.whl
Size 2.5 MB
Tags Python 3
SHA-256 checksum
How to use checksums
9ea99df26771997272b094cbf5d119606fdeb79d8c18ddb9162fea59e7cfdada
BLAKE2b-256 checksum
How to use checksums
c4e6f5ab830c7777172e40ab33f79318d83ae76f61e45aeffc81c257655f9f01
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.2.0 CPython/3.14.6

Security for sourcecode 5.9.28

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

5.9.28 This release

2 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page