Skip to content

ysz7/Arcforge

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

30 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Arcforge icon Arcforge

Platform: Windows x64 Plugin: Laravel Plugin SDK

Graph-based IDE and architecture explorer for backend projects.

Arcforge turns your backend into a navigable graph: controllers, services, models, and their dependencies become nodes and edges you can explore, understand, and refactor with more confidence.

  • Graph-first backend view — controllers, services, models, and relations as one navigable graph
  • </> Open node, read code — click any node to jump to the exact source file and line
  • Trace request flows — follow a request from HTTP entry through middleware, services, to the database
  • Design with Arcspec — design architecture from scratch and export AI-ready prompts for any language
  • 🔌 Plugin-powered — every language adapter is a plugin; install official or community plugins, or build your own
  • 🛡 Safer refactors — explore all dependencies before touching code

Open Beta · Windows desktop · Plugin SDK open for community contributions


Screenshots

Graph view
Graph view

Save as prompt
Save as prompt


Plugins

Arcforge is built around a plugin system. A plugin is a folder with three files:

File Purpose
manifest.json Metadata, accepts (directory/file), capabilities flags
nodes.js Node type definitions — shape, color, icon
parser.js async parse(input) — returns nodes and edges

What parser.js should extract — a concrete example

Your parse(input) receives the project root path. Walk the source files, read them, and map code constructs to nodes and edges:

Source code construct Maps to
Class / service / controller definition A node
import / require / use statement An edge ("depends")
Route registration (Route::get(...)) An edge ("handles")
ORM relationship (hasMany, belongsTo) An edge with the relation type
const fs   = require('fs').promises;
const path = require('path');
const glob = require('fast-glob');

exports.parse = async function parse(input) {
  const nodes = [], edges = [], nodeMap = {};

  // 1. Find all files you want to parse
  const files = await glob('app/**/*.php', { cwd: input });

  // 2. Read each file — extract class name → one node per class
  for (const file of files) {
    const src = await fs.readFile(path.join(input, file), 'utf8');
    const name = src.match(/class\s+(\w+)/)?.[1];
    if (!name) continue;

    const n = node('controller', name, { filePath: file });
    nodes.push(n);
    nodeMap[name] = n.id;          // keep id for edge wiring below
  }

  // 3. Read again — extract "use" imports → one edge per dependency
  for (const file of files) {
    const src = await fs.readFile(path.join(input, file), 'utf8');
    const owner = src.match(/class\s+(\w+)/)?.[1];
    if (!owner || !nodeMap[owner]) continue;

    for (const [, dep] of src.matchAll(/use\s+[\w\\]+\\(\w+);/g)) {
      if (nodeMap[dep]) edges.push(edge('depends', nodeMap[owner], nodeMap[dep]));
    }
  }

  return { nodes, edges };
};

Official plugins:

  • Laravel — Models, Controllers, Routes, Views, Migrations
  • Arcspec Designer — free-form architecture design, exports AI-ready prompts (.arcspec)

Build your own: grab the SDK templates and AI prompt from /SDK.

⚠️ Plugins run with full Node.js access to your file system. Only install plugins from sources you trust.


Status

Open Beta · Windows (x64) · v1.3.0

Updates are distributed via GitHub Releases and a static updates.json manifest checked on startup. There are no background services, telemetry, or tracking.


Download


Safety & limits in Open Beta

  • Arcforge focuses on reading and visualizing your codebase — it will not modify your code automatically.
  • Best suited for understanding and planning, especially small-to-medium projects.
  • For very large production monoliths, performance may vary — share feedback with project details if you hit issues.

License

See the LICENSE file for details.

About

Architecture design IDE for building and visualizing backend logic. Explore relationships, generate boilerplate, and perform safe refactors without losing track of how everything connects.

Resources

License

Stars

Watchers

Forks

Contributors