Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

ArchLang compiles .arch text to SVG floor plans. Before writing any .arch, read the archlang://spec resource: the whole language (from a shell: npx -y @chanmeng666/archlang spec). The loop:

  1. Write the plan as .arch source.

  2. compile it. Errors are diagnostics, usually with a byte span, often a fix; fix applies the machine-applicable ones, edit the rest by hand.

  3. describe it; check rooms, areas and doors against the brief.

  4. validate with strict:true (parse, resolve, lint); fix every warning, then back to 2.

  5. finish once lint is clean, before export: it furnishes empty rectangular rooms on every storey and adds the missing sheet statements (paper, scale, dimensions, title, room schedule, legend). With a shell, the CLI runs the same loop at no context cost: archlang <cmd>, or npx -y @chanmeng666/archlang <cmd> without a global install.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}
resources
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
compileA

Compile ArchLang .arch source (or a Plan-JSON object) to an SVG floor plan, or with format to a plain-text ASCII plan ("txt"), Plan JSON ("json") or an image ("png"). Format "json" returns the plan as an object, with schema naming its JSON Schema; passed back as plan_json it compiles to the same drawing, unless the plan uses a part of the language Plan JSON does not carry (sheet tables, styles, circular rooms, roofs, storeys, place, accessibility metadata). Returns the output plus diagnostics; a diagnostic usually carries a byte span with line/col and an E_/W_ code, and often a fix, sometimes one the fix tool can apply. Errors come back as data, never as exceptions: read diagnostics and correct the source. A multi-storey plan (level <n> { … }) returns the lowest storey in output and every storey in pages[] ({ level, name, output }); pass level to render just one. format "png" returns the usual result as text, then the drawing (the lowest storey, or level) as image content, as wide as width says; it needs the optional renderer @resvg/resvg-js, and without it the call returns ok:false with an error saying how to install it.

describeA

Report a plan's facts without rendering, so you can check it against the brief without looking at an image. Returns rooms (area, bbox, adjacency, use, and the exact shape: floor_polygon for a room polygon, floor_circle for a room circle, whose area is exactly πR²), doors (what each connects), windows, circulation (walk distance, bottleneck width, detour), zones, storeys (levels[i] carries the same facts per floor) with the shafts that join them and which storeys stay reachable (vertical), the drawing extent (bbox, bbox_outer), freedom (which positions are hand-authored and which are derived), and totals.

lintA

List advisory architectural-soundness warnings (W_* codes) as data: unreachable room, windowless bedroom, too-narrow door, blocked doorway, furniture through a wall, circuitous path, and more. profile selects a ruleset ("residential-basic", "accessibility-advisory", …).

validateA

Check a plan in one pass without returning a drawing (parse, resolve and lint): the gate a plan passes before it ships. strict:true makes advisory warnings fail too. Optional graph checks the plan's interior-door adjacency against an intended room graph ({ room: [neighbours] }); a mismatch fails. Optional intent (a brief's expectations, shaped as the archlang://intent-schema resource describes) is checked against the plan: a missed gating assertion (room count, existence, area, total area, windows) fails, while adjacency and reachability are advisory and only score. A malformed intent returns { ok:false, intentErrors } as data, never an exception. Returns { ok, diagnostics, graph?, intent? }.

scoreA

Measure how much of a brief's intent JSON a plan satisfies, without gating. Returns { ok, satisfied, total, score, subscores, violations }, where score is satisfied/total in [0,1] (an empty intent scores 1); call it across edits to watch a plan approach the brief. The intent's shape is the archlang://intent-schema resource. A malformed intent returns { ok:false, intentErrors } as data, never an exception.

repairA

Correct furniture placement and return the corrected .arch source with a change log. It pushes furniture out of walls, doorways and door swings, separates overlapping pieces, moves fixtures that sit in the wrong room, and snaps floating pieces to walls. A piece it may not rewrite is listed in unresolved with the reason. It never adds doors or windows (that is a design choice); use suggest for those.

fixA

Apply the machine-applicable fixes attached to a plan's compile diagnostics and return the edited source. It corrects source-level faults (an opening off its wall becomes the attachment form, an out-of-range position is clamped, …); furniture geometry is repair's job. It runs at most 4 passes and rolls back a pass that raises the error count. unsafe:true also applies maybe-incorrect fixes. Returns { ok, passes, applied, skipped, source }.

finishA

Complete a plan for export by adding what it lacks; run it once lint is clean. Two stages. furnish puts furniture, by room use, in each rectangular room that holds none, on every storey (a furnished room is never touched, and one that lacks a piece its use requires is named in unresolved with the missing pieces, not filled; placement is against wall / in <room> anchor, never absolute). sheet adds the sheet statements the plan lacks (paper, scale, dims auto, title, schedule rooms, legend), choosing the finest standard scale on the smallest sheet that holds the drawing. It fills only what is missing and deletes nothing; only runs one stage; reissue:true may replace paper/scale (only those) when the drawing does not fit them. Returns { ok, changed, changes, unresolved, source }; a plan that does not compile comes back untouched with ok:false, and every room left empty (its use has no furniture row or is unknown, or furnishing it would raise a new diagnostic) and every sheet statement left out is named in unresolved with the reason; a note with scope set (outside-table) asks nothing of you unless that room should hold furniture.

suggestA

Suggest the doors and windows a plan's room graph needs, as data; nothing is applied. For a room with no path back, a building with no entrance, a bath reachable only through a bedroom, or a windowless bedroom, it returns ready-to-paste door/window statements with a rationale, for you to choose among and insert. Each names its wall by an authored id or a unique wall category, else by absolute at (x, y) coordinates. Door candidates avoid furniture in the door's approach; window candidates do not consider furniture.

completeA

List the completion items in scope at a source byte offset: keywords, element names, ids and enum values, the same items an editor's language server offers. For structured or assisted authoring.

linkA

Make two URLs that show a plan in the browser with nothing to install, for handing to a person. playground opens it in the hosted editor, rendered; embed draws it alone, for an iframe. The plan travels inside the URL, after the #, so it is never sent to a server and the URL carries nothing else. A plan that does not compile still gets links, and the page shows its diagnostics; ok says whether it compiles, and errors counts the errors when it does not. bytes is the size of the compressed plan in the URL.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription
specThe whole ArchLang language on one page. Read it before writing any `.arch`.
contextThe spec, the authoring workflow, the CLI reference and the error catalog in one document, for a system prompt.
schemaJSON Schema (2020-12) for the Plan-JSON object `compile` accepts as `plan_json`.
grammarGBNF grammar that constrains generation to ArchLang's statement shapes; it is looser than the parser, which remains the authority.
intent-schemaJSON Schema (2020-12) for a brief's Intent — the shape `validate`'s `intent` and `score`'s `brief` take.

TDQS

A4.1/5.0

Scored across 11 tools

Disambiguation4/5

Most tools have clearly distinct purposes, but a few pairs require careful reading: fix vs repair both edit source, lint vs validate both report diagnostics, and score vs validate both check intent. The descriptions explicitly delineate these boundaries, so misselection is unlikely but not impossible.

Naming Consistency5/5

All tool names are single lowercase imperative verbs with no mixed conventions or underscores. The pattern is predictable throughout the set.

Tool Count5/5

Eleven tools is well within the appropriate range for a language tooling server covering authoring, validation, repair, finishing, and sharing. Each tool appears to earn its place without obvious redundancy.

Completeness4/5

The surface covers the full lifecycle: completion, compile, validate, lint, fix, repair, suggest, finish, describe, score, and link. Minor gaps like a dedicated format/explain tool are not critical, as compile and diagnostics cover those needs.

Maintenance

ActivityActive
ResponsivenessSyncing