Codecanvas

Install

Works with Claude Code, Codex, VS Code, Cursor, Windsurf, Claude Desktop. Read the repository before you give any tool access to your data.

npx agentmarket install connector/donggyun112-codecanvas

About

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this server can do and what it asks for, from its tool list and install config. Checked Oct 25, 2026.

Tools

8 read · 4 write · 0 delete · 1 not yet classified

Secrets

None asked for

Install scripts

Not scanned yet

Runs as

Python package

Tools (13)

Read from the source code; the running server may differ. Descriptions are the server’s own words; hidden characters are shown as [U+…].

• analyze_impact

  Assess the blast radius of a change — given a diff or git ref, list the changed functions and which entry points/public surfaces they affect (HTTP routes, scripts, or public function fallbacks). Reach for this when reviewing a PR or before merging, to see what a set of edits could break downstream. Pass `diff_text` for an inline diff, or `git_ref` to diff against a ref. Entry points whose handler is under a test path are hidden by default (consistent with `list_entrypoints`); set `include_tests=True` to keep them. Non-Python changed files are reported under `skipped_files`. Prefer `affected_e…

• call_tree

  Trace everything a function reaches downstream — the forward transitive call tree, N hops deep, in one call instead of hopping node-by-node. Reach for this to see what a function ends up doing and which side effects it triggers transitively. The complement of `who_calls`, which walks the opposite direction (upstream, who calls it). Each node carries its `depth`, the `via` caller on the traced path, effect flags (db/http/raises/stub) with `effect_scope: "direct"` — a node's flags are always its own, never its subtree's — and risk. The top-level `effects` splits the queried function's own effec…

• find_symbols

  Find project functions, methods, and classes by name, qualified name, scope, acronym, or docstring meaning. Results explain matched tokens, character spans, and likely symbol role. Continue with `next_cursor`; choose `search_mode` name, semantic, or hybrid. `semantic` is concept-expanded lexical matching over identifier words plus docstrings — related wordings reach each other (throttle/limiter, parallel/concurrency), but it is not an embedding search, so a query sharing no vocabulary with the code will not find it. Every row reports `match.coverage`: the fraction of the query's content words…

• function_flow

  Understand how a function works internally without reading the full source. `flow` is a structured branch tree with explicit `subject`, `scope`, `condition`, and `nested_subjects`; `outline` is a compatibility rendering. For exact return/raise guards, use `reaching_conditions`. `function` accepts a qualified name, bare name, file:line, or scope-skipping suffix.

• list_entrypoints

  Map where a codebase starts — list its API/HTTP routes, CLI scripts, public library exports, and entry-point functions. Reach for this first to get the lay of an unfamiliar project: what endpoints exist, which handler serves each route, where execution begins. For a library, `kind="export"` is its public API surface, taken from each distributed package's `__all__` and `[project.scripts]` and resolved to where each name is defined. Every export is tagged with its distribution. On large projects the result is capped, so narrow it: `filter` is a case-insensitive substring matched over method/pa…

• logic_flow

  Start here to understand an unfamiliar function's logic in one compact call. Combines symbol resolution, signature and summary, branch outline, guarded outcomes, downstream project calls, effects, and repository-relative citation locations. Prefer this over separately calling `find_symbols`, `what_does`, `function_flow`, `reaching_conditions`, and `call_tree`; use those only when this response is truncated, ambiguous, or needs one focused detail. `depth` bounds downstream calls and defaults to two hops.

• project_status

  Inspect the active analysis root, Python file count, disk-cache state, and nested Python project roots. Use this when results look polluted or incomplete and you may need a narrower `project_path`.

• reaching_conditions

  Find out under what conditions a function reaches each of its returns and raises — the guard/path conditions (the enclosing if/elif/else, except, and loop tests) leading to each outcome. Reach for this when hunting a bug in branching logic or asking "why does this hit the error path?": it surfaces error-path vs success-path asymmetries (e.g. a success response returned from an except handler), plus cyclomatic complexity and any unreachable/dead code. `target`: omit for all return/raise; or "return" / "raise" / "line:N" to focus. `function` = qualified name, bare name, file:line, or a scope-ski…

• simulate_state_transition

  Execute focused state-transition repro cases in isolated processes. Pass explicit `cases` for exact domain states, or omit them to generate a small schema-shaped set from `state_schema`; generated cases do not derive branch predicates, so use `function_flow`/`reaching_conditions` plus explicit cases when branch coverage matters. Built-in invariants include `no_exception`, `return_is_mapping`, `return_has_required_keys`, `no_unknown_return_keys`, and `state_preserves_required_keys`. Results include return values, state mutations, exceptions, captured output, and per-case violations. Exceptions…

• validate_state_schema

  Check a function's state dict/object usage against expected fields. Use this when a bug depends on domain state shape rather than call graph reachability alone. `state_schema` may be JSON-schema-like (`{"properties": {...}, "required": [...]}`) or a simple field mapping. The tool reports state reads/writes, dict-shaped returns, schema-extra fields, and returns missing required fields. `state_var` must match the function parameter that receives the whole state mapping; these tools are designed for node-style functions such as `def node(state)`. This is a focused repro aid: it turns custom stat…

• verify_claim

  Verify a qualified reachability claim before summarizing it. Use `<source> reaches <target>`, optionally prefixed with context such as `root task-mode`. The result combines static call paths, structured `function_flow`, and `reaching_conditions`, returning `true`, `false`, or `uncertain` plus a counterexample/qualification. Inferred-only paths never receive a true verdict. Condition qualifiers on the prefix are evaluated, not ignored: `dry-run publish reaches _call_api`, `wake=false deliver reaches _send`, and `without OPENAI_API_KEY analyze reaches run_ai` each get checked against the guard…

• what_does

  Get a quick summary of what a function does without reading its source — its signature, docstring, side effects (whether it touches the database or makes HTTP calls), the exceptions it can raise, and a risk rating. Use it to triage an unfamiliar function before deciding whether to dig into `function_flow` or the full source. `function` = qualified name, bare name, file:line, or a scope-skipping suffix like `Class.nested`. `calls` and `effects.direct` cover this function's own call sites, and `risk` scores only those. `effects.transitive` names what it reaches through callees, each attributed …

• who_calls

  Find the callers of a function — who calls it, its upstream usages and references, the reverse call graph, and what would break if you change its signature. Complements `call_tree`, which walks the opposite direction (downstream, what the function reaches). `function` accepts a qualified name, bare name, file:line, or a scope-skipping suffix like `Class.nested` (an enclosing scope omitted). `depth=1` (default) returns direct callers; `depth=N` walks up to N hops of transitive callers, tagging each with its `depth` and the `callee` it calls on the traced path. Cycles/recursion terminate safely…

Signals

Stars

2

Forks

0

Open issues

0

Weekly downloads

92

Last commit

Sep 12, 2026 (1 month ago)

Last release

Sep 12, 2026 (1 month ago)

Last package publish

Sep 12, 2026 (1 month ago)

From GitHub (fetched Oct 24, 2026) and the package registry.

Details

Registry name

io.github.donggyun112/codecanvas

Version

0.1.20

Auth

No auth

Packages

pypi codecanvas-mcp

License

MIT

Repository

github.com/donggyun112/codecanvas

First seen

Oct 24, 2026

Last checked

Oct 25, 2026

Source

Official MCP Registrygithub-graphql