Backlog

Next up

In Progress

Done

Main Roadmap

It would be nice to be able to select a Git commit and TangleGuard shows the dependency graph of that commit.It would be even nicer if TangleGuard could then compare those two versions of the architecture, or even multiple versions to detect trends 📈

In Review

Time Traveling

As I developer of a private software project i want all developers of the team to browse the codebase visually, without everybody having to install the desktop app. I don’t want to host it on the internet though, but rather install my own TangleGuard Cloud instance in my company on my own servers and with my own database.

Self Hosted Web App

Currently, one can declare dependency rules for top-level components in their programming language. Meaning, one can declare rules between packages for Rust or JavaScript, or between Module for Go projects. More about it <a target="" rel="noopener noreferrer nofollow" class="link" href="https://tangleguard.com/docs/welcome/building-blocks">here</a> or <a target="" rel="noopener noreferrer nofollow" class="link" href="https://tangleguard.com/docs/features/custom-rules">here</a>.TangleGuard checks the source code against any rule violations, locally or within CI/CD pipelines, so make sure the attended structure stays in place.Now this could be enhanced to also support smaller sized projects, which don’t rely on a workspace. So like a single-package/crate binary in Rust or a single JS package.

Second-Level Layer Validation

Go does not include specific items in the `import` statement. Therefore the edges in the diagram go into the packages (the parent node), not in the Go files nodes. It would be nice though to have those edges go into the go file nodes instead of to the parent node for more accurate visualization and hence easier detection of architectual flaws

File Relations between Go Files

Currently only the macOS releases are being signed and Windows not. The user get’s a warning about that which is not very nice. Signing would remove that warning and can be done using services like <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="http://ssl.com">ssl.com</a>

Sign Windows Desktop App

Currently only open source projects are supported by the Cloud version, because they are available to be analyzed by the general public.But to host the analyzation data of private repositories should also be possible, too. For this proper multi tendency support needs to be implemented, which means:<ul><li>encryption of the stored data at rest</li><li>handling of tokens and likely encryption keys</li><li>row level security</li></ul>

Private Projects in Web App

See how a pull request will effect your structure. This would include<ul><li>nodes (packages / modules / namesspaces/ etc.)</li><li>dependencies</li></ul>In a PR, a comment could add a graph diagram which shows the effected nodes and edges

Show Effects in PR

Planned

Java Support

TangleGuard vs. SonargraphTangleGuard vs. CodeChartTangleGuard vs vFunctionetc.

Comparison to similar Tools

As a user I want to integrate my project onto <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://app.tangleguard.com/">https://app.tangleguard.com/</a> so I have a living documentation of the codebase without installation.

Self Service for Web App

So far the focus has been on human interaction via the GUI. But LLMs need a different way to communicate with TangleGuard.The CLI tool need to be enhanced and an MCP Server would be nice to have.

Interfaces for AI-Agents

When there are multiple edges between nodes, per default they are merged into a single edge for less noise in the diagram. the user can disable this in the dependency filter settings, but this view then can get a bit annoying.It would be nice to have thicker lines/edges for edges which represent multiple dependencies. the thicker - the more dependencies are flowing via this edges.

Completed

Dynamic Edge Width

Go Support

Python Support

I recently downloaded the latest version of Tangleguard (0.25.1) after having used 0.9.0 for the last few months and I’m missing some features I loved! Mainly, your package viewer used to display the layers in the package view.That is, the container for packages displayed as a box around the packages.It could be that instead of being another zoom level, it’s a toggle under Dependency Types which optionally shows the layers around the relevant objects.I saw that you just completed the same feature for modules and sub-modules. It’s the same thing, just up one.

Global Zoom Level - Layers

Sam Arrowsmith

Currently a user might wonder what to do after exploring the codebase.Some recommended actions would tell the user what to do, to improve the codebase.Onboarding<ol><li>Add at least two Layers</li><li>At least one rule</li></ol>Resolve Issuescircles and rule violations

Recommendations

Define target architecture and let TangleGuard find interdependencies which do not align with the target architecture

Dependency Rule System

Groups and dependency rules currently rely on filesystem paths, see <a target="" rel="noopener noreferrer nofollow" class="link" href="https://tangleguard.com/docs/features/validation">here</a>. So they have to be define like this: <pre><code>groups:
 - name: apps
paths:
 - "apps/**"
 - "ui-shares/wasm/**"</code></pre> I’d like to also support having those rules based on packages or component names. Here’s an example: <pre><code>groups:
 - name: api-layer
packages:
 - tangleguard-rest-api
 - tangleguard-graphql-api
 - tangleguard-middlewear-api</code></pre>

Filesystem independent Dependency Rules

It can get very hard to find a specific node in large codebases. Therefore a text search would be nice, where the node(s) get highlighted for easy lookups

Search for components

One level for all nodes. Level 0 are top level building blocks, like packages for Rust and JavaScriptLevel 1 are the second top level building blocks Level 2 are nested building blocks