breeze

Plugin breeze from marketplace breezeai-plugins in accionlabs/breezeai-claude-plugin. Commands read from the repo's manifest — 8 days ago.

Skills (29)

• analyze-architecture

  Analyze a requirement (from Jira, document, image, diagram, or text) against the existing Architecture Graph. Maps the requirement to the 8-layer model, runs impact analysis via the Code Graph, anchors user-facing components to Functional Scenarios, detects reuse opportunities and gaps, and writes a

• analyze-design-deviations

  Compare Figma design system components against the Breeze design graph component registry. First builds existingcomponents.json by iteratively fetching all Component nodes from MCP, then reads a user-provided figmaComponents.json file and performs a multi-dimensional comparison: name matching (with

• analyze-design

  Generate design graph nodes (UserJourney, Flow, Page, Component) from any input: Jira ticket, plain-text description, scenario references, or Figma wireframes. Builds requirement context, resolves matching functional graph scenarios/steps/actions, generates design nodes with component reuse, and opt

• analyze-functional

  analyze the functional against the existing functional graph which can be access using breezeAi mcp tools. Identifies coverage gaps, conflicts, dependencies, and impact. Use when: "analyze this requirement", "is this covered", "impact of this change", "break down this user story".

• code-ontology-audit-check

  Run a full Breeze code ontology audit for one or all repos. Checks file coverage, function/class/LOC counts, intentional exclusions, and ghost files. Use when validating a repo's code graph completeness.

• deprecated-cluster-pipeline

  DEPRECATED. Old Python multi-pass cluster pipeline that generated a functional graph from the code graph via intent extraction → DBSCAN clustering → outcome assignment → scenario generation. The DBSCAN clustering step produces duplicate scenarios under realistic repo layouts, which is why this skill

• detect-personas-monorepo

  Detect user personas from all frontend apps inside a monorepo in parallel. Analyses routes, layouts, subscription tiers, roles, feature flags, and access control patterns. Handles Nx, pnpm, Lerna, Turbo, and npm/yarn workspace monorepos — auto-discovers frontend apps, launches one agent per app in p

• detect-personas

  Detect user personas from a frontend UI repository by analyzing routes, layouts, subscription tiers, roles, feature flags, and access control patterns. Optionally create or update personas in the Breeze functional graph. Use when: "detect personas", "identify personas", "who uses this app", "find us

• generate-architecture

  Generate the complete Architecture Ontology for a project from ANY source — a codebase, a Terraform/IaC tree, SQL DDL or Elasticsearch mappings, an architecture spec document, a Confluence page, or any combination. Auto-detects what it is pointed at, maps every component to exactly ONE of the 8 arch

• generate-code

  Generate code and test cases informed by the functional graph and code graph. Ensures implementations align with requirements and existing patterns. Scoped by persona: a System (or External System) persona generates a backend; any non-System human persona generates the user-facing UI; a mixed select

• generate-component-registry

  Scan a frontend UI codebase (single-repo or monorepo with multiple frontend apps) to discover all components, classify them by atomic design level (ATOM, MOLECULE, ORGANISM, TEMPLATE), and build the `existingcomponents.json` registry. Optionally upserts Component nodes to the Breeze design graph. Us

• generate-design-from-ui

  Generate design graph (UserJourney, Flow, Page, Component) from functional graph scenarios, enriched by reading the actual frontend UI codebase. Scenario->UserJourney, Step->Flow/Page, Action->Component. Use when: "design from UI", "ui to design graph", "generate design from frontend", "map ui to us

• generate-functional-from-aspnet-webforms

  Generate the WHOLE functional graph (both the human/User half AND the System half) for a classic ASP.NET **Web Forms** monolith — UI and backend live in ONE repo, ONE process, with NO network boundary (a `.aspx`/`.ascx` presentation tier calls a `*Facade`/`*Service`/`SqlProcs` business tier in-proce

• generate-functional-from-backend

  Generate the System / External System half of the functional graph from a backend repo (REST routes, GraphQL operations, queue / event / cron handlers) using a rooted per-entry-point sub-agent depth pass. The parent discovers entry points; an installed agent (breeze:backend-flow-structuring-agent) p

• generate-functional-from-metadata

  Generate the full functional graph (Persona → Outcome → Scenario → Step → Action → apis[]) from a Vert.x metadata-driven codebase (the kind where features are declared in MAPL/MSCR/MFID/MFLT/CRUD JSON, not imperative code). One run at the tree root discovers every application by parsing MAPL records

• generate-functional-from-ui

  Generate User-persona functional graph from a frontend UI repo with rooted per-(EP, persona) sub-agent depth pass, mandatory field enumeration, persona-conditional visibility audit, Code_Graph_Search escalation (no budget cap), and Python-helper validators (schema / rule-a / forbidden / citations /

• generate-page-registry

  Scan a frontend UI codebase's router to discover pages, classify each by page type (LIST, DETAIL, FORM, DASHBOARD) and build the `existingpages.json` registry that `generate-design-from-ui` reads. Scans every route, or only the screens of chosen outcomes / scenarios. Use when: "build page registry",

• generate-spec

  Generate a functional specification document from the functional graph. Outputs structured Markdown grouped by persona with citations. Use when: "generate spec", "generate document", "functional spec", "create specification", "export functional graph".

• impact-analysis

  Searches Breeze functional, design, code, and architecture graphs to perform impact analysis of a proposed change. Shows an analysis summary and optionally generates a detailed document with diagrams. Use for: "impact analysis", "what if we change X", "what breaks if Y fails", "blast radius of Z" —

• onboard-project

  End-to-end onboarding orchestrator for a brownfield estate — one repo, a monorepo, or hundreds of services. Builds a workspace plan, onboards every repo into the code graph (via onboard-repository), classifies the code into units (SPA, backend service, Web Forms app, MVC app, metadata app, shared li

• onboard-repository

  Get one repository, a list of repositories, a whole GitHub organisation / GitLab group, or a monorepo into the Breeze code graph for the current project. Default mode is GIT LINK: the repo is connected to Breeze (GitHub, GitLab, Bitbucket, Azure DevOps) and parsed server-side, with ignore patterns s

• project

  Full Breeze project management: show, list, switch (use), create, auth, status, and full bootstrap (setup). Use for: "which project am I on", "list projects", "switch project", "set project", "create project", mid-session project changes, MCP re-authentication, and first-time workspace bootstrap. Th

• search

  Search the functional, design, code, and architecture graphs to answer questions about the system. Smart-routes to one graph, a subset, or all of them based on query intent. Use for: feature discovery, "how does X work", "who handles Y", finding code or UI implementations, schema lookups, and cross-

• update-design-from-diff

  Incrementally update the design ontology (UserJourney, Flow, Page, Component) from a git diff between two commit IDs. Scopes work to only the UI files that changed — no full regeneration. Use when: "update design from diff", "sync design graph with commits", "incremental design update", "design grap

• update-functional-from-diff

  Incrementally update functional ontology (UI + backend) and design ontology (UI) from a git diff between two commit IDs. Use when: "update functional from diff", "sync graph with commits", "update functional from commits", "incremental functional update", "diff-based graph update", user provides two

• update-functional-graph

  Create or update nodes in the functional graph (Persona > Outcome > Scenario > Step > Action) from code, documents, or Figma designs. Use when: "update functional graph", "add to graph", "capture this in the functional graph", after analyzing a Figma frame, document, or code cluster.

• validate-design-graph

  Validate the design graph for structural integrity, ontology compliance, and functional graph linkage. Supports validating all personas or a selected subset. Checks orphan nodes, empty hierarchy, duplicate names, missing scenarioIds, invalid enums (lowercase modality/pageType/type), template complia

• validate-functional-graph

  Validate the functional graph against source documents. Checks coverage, duplicates, persona quality, description completeness, action platform-agnosticism, and citation traceability. Use when: "validate graph", "check graph quality", "compare graph to docs", "audit functional graph", "graph health

• visual-to-text

  Generate user stories from UI design visuals (Figma frames, PDF screens, or images) that describe the functional intent behind the visual design, expressed in terms of personas, outcomes, scenarios, steps, and actions. Outputs structured user stories aligned with the functional graph and saves them

Subagents (10)

• app-backend-module-agent

  Build ONE backend feature module (routes/handlers + services + validation + tests) of an application from a set of assigned functional-graph outcomes. Reads every Outcome → Scenario → Step → Action for the assigned outcomes (via the Breeze functional-graph MCP tools), honouring the API contracts on

• app-ui-module-agent

  Build ONE frontend feature module of an application from a set of assigned functional-graph outcomes. Reads every Outcome → Scenario → Step → Action for the assigned outcomes (via the Breeze functional-graph MCP tools) so that every action becomes a real UI behaviour, then writes a self-contained, t

• aspnet-razor-flow-structuring-agent

  Take ONE ASP.NET MVC / Razor Pages entry point (a controller action that returns a View, or a Razor Page .cshtml + PageModel) plus the persona that owns it, read the Razor view + layout + partials/view-components + the action/PageModel + the view-model, produce a complete human-persona Functional Gr

• aspnet-webforms-flow-structuring-agent

  Take ONE ASP.NET Web Forms entry point (.aspx page / .ascx control) plus the persona that owns it and trace the WHOLE in-process chain end-to-end — markup + code-behind → façade/service → (in-process OR WCF/ASMX service-proxy) → repository → SQL/stored-proc / side-effects — then emit BOTH halves of

• backend-entrypoint-discovery-agent

  Inventory ALL entry points in a backend repo — REST routes, GraphQL operations, and queue/event/cron handlers — plus orphan handlers, then write the full inventory to entrypoints.json on disk and return a single compact summary line (counts + path + flags). Designed to be invoked ONCE by the generat

• backend-flow-structuring-agent

  Take ONE backend entry point (REST route, GraphQL operation, or queue/event/cron handler) plus its mechanical persona (System or External System), read the handler and every constructor-injected service/repository/client, produce a complete Functional Graph subtree (Persona → Outcomes → Scenarios →

• design-from-ui-structuring-agent

  Take ONE outcome (with all its scenarios), run grep discovery, read the actual UI code, classify components by atomic design level, build Design Graph subtrees (UserJourney → Flows → Pages → Components) for every scenario in the outcome, self-validate, write payloads to disk, and upsert via Bulk_Upd

• metadata-application-discovery-agent

  Inventory ALL metadata-driven applications across a tree of Vert.x metadata modules by parsing every MAPL(*) record (plus module class and resolved personas), write the full inventory + checkpoint to applications.json on disk, and return a single compact summary line. Designed to be invoked ONCE by

• metadata-flow-structuring-agent

  Take ONE metadata-driven application (its MAPL recipe + module info) plus its resolved personas, read the MAPL steps and every referenced MSCR/MFID/MFLT/CRUD/Java target, enumerate 100% of declared fields, produce TWO linked Functional Graph subtrees (a Human-persona half from ShowScreen steps and a

• spa-flow-structuring-agent

  Take ONE frontend (single-page app — React/Vue/Angular/Next) entry point plus the persona that owns it, read the relevant code, produce a complete Functional Graph subtree (Persona → Outcomes → Scenarios → Steps → Actions) byte-valid against the upsert schema, self-validate it (schema / rule-a / for

MCP servers (1)

• breeze-mcp

  connects to: https://breezeai-mcp-python.accionbreeze.com/mcp

Similar plugins