io.github.raulbr90/changebook

A single prioritized list of what to address in this project, most urgent first: open regressions (a change already broke something), at-risk health controls (a safety posture the analysis flagged), hotspot modules (fragile by design) and repeat-offender modules. Pure aggregation of signals the atlas already holds — no new analysis, ordered by transparent severity tiers rather than a hidden score. Use it to decide where to start, then ANNOUNCE your pick and wait for the user's OK before acting. project: the repo you are working in (folder name or slug).

Mark a task from atlas_pending_tasks as done (or dismissed if it no longer applies). Pass the task id. Closing an already-closed task is a no-op.

Call this BEFORE you edit, change, fix or refactor any file or function: it tells you how many times each file's module already broke here (recidivism) and its open regression alerts, so you touch it knowing what bit people last time. One cheap call instead of re-reading the code and its git history. It also returns, per file: the module it belongs to and its risk, how often it changed recently, the recent commits that touched it (cite these instead of running git log), and the CURRENT value of watched config constants (with the commit it comes from — no need to re-read the file for those). Args: - files (required): 1-8 repo-relative paths. - project (recommended): the repo you are working in (folder name or slug). The atlas is per-project — always scope to your own project. Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_changed, last_note }], open_alerts, recidivism: [{ module, prior_regressions }], recent_commits: [{ commit, commit_aliases, date }], recent_commits_more, watched_values: [{ name, value, commit }] }] }

Call this WHEN you need a module's recent history instead of re-reading its source: what changed, why it matters, the files touched and (when available) a verbatim excerpt of each diff. The token-saving way to catch up on a module — its recent evolution and risk picture — in one call before you touch it. Args: - module (required): exact module name as returned by atlas_modules. - limit (1-20, default 5): number of recent changes to include. - include_excerpts (default true): include diff excerpts (short previews unless full is set). - full (default false): return the diff excerpts verbatim instead of the token-saving previews. Only pass it when you actually need the code lines. - project (recommended): the repo you are working in (folder name or slug). The atlas is per-project — always scope to your own project. Returns (structured): { module, count, changes: [{ date, commit, risk, note, tech, files, business_impact, excerpt, excerpt_truncated }] }. Notes describe the code AS OF their commit/date — verify current values in the code before asserting them.

List the modules of the product as known by ChangeBook, aggregated from the change history. For each module: domain, latest risk level, number of analyzed changes and last-change date. Files, notes and diffs live in atlas_module_detail — this is the map, not the terrain. Args: - domain (optional): filter by domain (e.g. "billing"). - project (recommended): the repo you are working in (folder name or slug). The atlas is per-project — always scope to your own project. Returns (structured): { count, modules: [{ module, domain, risk, changes, last_changed }] }

Pending tasks the owner queued for YOU. Returns id, title and a short excerpt; pass `task_id` for one task's full body, context and done-criterion. Tell the user which one you picked and wait for their OK before starting; close it with atlas_complete_task. project: the repo you are working in (folder name or slug).

Call this FIRST, the moment a session opens, to get your bearings: it hands you the module map with risks, the open regression alerts, the project health (which safety controls the analysis has evidenced as passing or at-risk), the tasks the owner queued for you, and the latest analyzed changes — ONE call that replaces atlas_modules + atlas_pending_tasks + atlas_recent_changes. Optional intent widens the SAME call (never a second trip): intent=orient serves 10 recent changes with commit+files; intent=pre_edit with files=[paths] appends each file's modules, notes and current watched values; intent=feature with feature="text" appends the changes matching that text. After reading it, tell the user in 1-3 lines what you found and what you plan to do, and WAIT for their OK before editing any code — announcing and then editing in the same turn leaves the owner nothing to decide. project: the repo you are working in (folder name or slug).

List the most recent analyzed code changes from the ChangeBook changelog (newest first). Each entry has a business-level impact summary, an optional technical summary, and the modules it touched. Use this to catch up on what changed in the product without re-reading the codebase. Args: - limit (1-50, default 10): entries to return. - offset (default 0): pagination offset. - search (optional): case-insensitive text filter over the business and technical summaries. - project (recommended): the repo you are working in (folder name or slug). The atlas is per-project — always scope to your own project. Returns (structured): { count, offset, has_more, changes: [{ id, date, commit, business_impact, diff_chars, files, files_more, modules: [{ module, risk }] }] }. files is a capped union (files_more = paths cut). Pass include_tech for summary_tech. Don't use for per-module deep dives — use atlas_module_detail for that.

Call this right AFTER you make or commit a change, so the atlas stays current. Send the unified diff (e.g. `git show <ref>` or `git diff`) plus the commit hash and ISO date when available. ChangeBook's own AI analyzes it (business impact, modules, risk) — you only deliver the diff. ALWAYS pass `project` = the repo folder name you are working in (the atlas is per-project; a new name creates the project). ALWAYS include `summary`: 2-5 sentences in your own words on what changed and why (intent, user-visible effect, risks) — you already know this, and it routes the analysis to a much cheaper model. Re-sending the same commit is a free no-op.

Close this project's open regression alert(s) once you have judged them, so the analysis stops re-raising them and stops re-queuing the owner's task. Call it with `verdict:"fixed"` when the alert was RIGHT and you fixed or confirmed the risk, and with `verdict:"dismissed"` when you CHECKED IT AND IT WAS WRONG — a false alarm, already handled, or about code that is deliberately that way. Refuting is as valuable as confirming: the accuracy this product reports needs both, and an alert you silently confirm to get rid of it makes that number a lie. Identify them by `module` (closes every open alert on that module) and optionally narrow with `symbol` (the evidence symbol the alert hangs on). Judge only what you actually looked at; it is reversible from the web. project: the repo you are working in (folder name or slug).

Account-level usage summary: what the owner paid for analyses this period, what ChangeBook's optimizations avoided (compression, prompt cache, Batch API, model routing, dedup skips) and how much agents consulted the atlas (with a conservative exploration-avoided estimate). Use when the owner asks about spend, savings, cost or usage. Args: period 'month' (default) or 'all'.