Time Traveling

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 📈

Self Hosted Web App

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.

Second-Level Layer Validation

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 here or here. 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.

File Relations between Go Files

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

Sign Windows Desktop App

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 ssl.com

Private Projects in Web 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: encryption of the stored data at rest handling of tokens and likely encryption keys row level security

Show Effects in PR

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

Java Support

Comparison to similar Tools

TangleGuard vs. Sonargraph TangleGuard vs. CodeChart TangleGuard vs vFunction etc.

Interfaces for AI-Agents

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.

Dynamic Edge Width

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.

Go Support

Python Support

Global Zoom Level - Layers

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.

Self Service for Web App

As a user I want to integrate my project onto https://app.tangleguard.com/ so I have a living documentation of the codebase without installation.

Recommendations

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 Add at least two Layers At least one rule Resolve Issues circles and rule violations

Dependency Rule System

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

Filesystem independent Dependency Rules

Groups and dependency rules currently rely on filesystem paths, see here. So they have to be define like this: groups: - name: apps paths: - "apps/**" - "ui-shares/wasm/**" I’d like to also support having those rules based on packages or component names. Here’s an example: groups: - name: api-layer packages: - tangleguard-rest-api - tangleguard-graphql-api - tangleguard-middlewear-api

Search for components

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

Configurable depth level

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