proschi 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,957 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  collectFiles: () => collectFiles,
+  format: () => format,
+  run: () => run
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// ../frontend/src/catalog/componentCatalog.ts
+var componentCatalog = [
+  // Generic Shapes
+  { type: "shape", techStack: "Rectangle", category: "Generic Shapes", searchTerms: "rectangle box square shape" },
+  { type: "shape", techStack: "Circle", category: "Generic Shapes", searchTerms: "circle round shape" },
+  { type: "shape", techStack: "Diamond", category: "Generic Shapes", searchTerms: "diamond rhombus shape decision" },
+  { type: "shape", techStack: "Cylinder", category: "Generic Shapes", searchTerms: "cylinder shape storage" },
+  { type: "shape", techStack: "Cloud", category: "Generic Shapes", searchTerms: "cloud shape" },
+  { type: "shape", techStack: "Actor", category: "Generic Shapes", searchTerms: "actor user person human shape" },
+  { type: "shape", techStack: "Note", category: "Generic Shapes", searchTerms: "note document comment annotation" },
+  // Services
+  { type: "service", techStack: "REST API", category: "Services", searchTerms: "rest api http service endpoint" },
+  { type: "service", techStack: "GraphQL", category: "Services", searchTerms: "graphql api service query" },
+  { type: "service", techStack: "gRPC", category: "Services", searchTerms: "grpc rpc service" },
+  { type: "service", techStack: "WebSocket", category: "Services", searchTerms: "websocket ws realtime service" },
+  { type: "service", techStack: "SOAP API", category: "Services", searchTerms: "soap api xml service" },
+  // AWS Serverless
+  { type: "serverless", techStack: "AWS Lambda", category: "AWS Services", searchTerms: "aws lambda serverless function" },
+  { type: "serverless", techStack: "AWS API Gateway", category: "AWS Services", searchTerms: "aws api gateway rest" },
+  // AWS Compute
+  { type: "compute", techStack: "AWS EC2", category: "AWS Services", searchTerms: "aws ec2 compute instance vm" },
+  { type: "container", techStack: "AWS ECS", category: "AWS Services", searchTerms: "aws ecs container docker" },
+  { type: "container", techStack: "AWS EKS", category: "AWS Services", searchTerms: "aws eks kubernetes k8s" },
+  { type: "container", techStack: "AWS Fargate", category: "AWS Services", searchTerms: "aws fargate serverless container" },
+  // AWS Storage
+  { type: "storage", techStack: "AWS S3", category: "AWS Services", searchTerms: "aws s3 storage bucket object" },
+  { type: "storage", techStack: "AWS EBS", category: "AWS Services", searchTerms: "aws ebs storage volume disk" },
+  { type: "storage", techStack: "AWS EFS", category: "AWS Services", searchTerms: "aws efs storage file system" },
+  // AWS Database
+  { type: "database", techStack: "AWS RDS", category: "AWS Services", searchTerms: "aws rds database relational sql" },
+  { type: "database", techStack: "AWS DynamoDB", category: "AWS Services", searchTerms: "aws dynamodb database nosql" },
+  { type: "cache", techStack: "AWS ElastiCache", category: "AWS Services", searchTerms: "aws elasticache redis memcached cache" },
+  { type: "database", techStack: "AWS Aurora", category: "AWS Services", searchTerms: "aws aurora database mysql postgresql" },
+  // AWS Messaging
+  { type: "queue", techStack: "AWS SQS", category: "AWS Services", searchTerms: "aws sqs queue message" },
+  { type: "queue", techStack: "AWS SNS", category: "AWS Services", searchTerms: "aws sns notification topic pubsub" },
+  { type: "queue", techStack: "AWS EventBridge", category: "AWS Services", searchTerms: "aws eventbridge event bus" },
+  { type: "queue", techStack: "AWS Kinesis", category: "AWS Services", searchTerms: "aws kinesis stream data" },
+  // AWS CDN/Network
+  { type: "cdn", techStack: "AWS CloudFront", category: "AWS Services", searchTerms: "aws cloudfront cdn edge" },
+  { type: "cdn", techStack: "AWS Route53", category: "AWS Services", searchTerms: "aws route53 dns domain" },
+  { type: "cdn", techStack: "AWS Load Balancer", category: "AWS Services", searchTerms: "aws alb elb load balancer" },
+  // GCP Serverless
+  { type: "serverless", techStack: "GCP Cloud Functions", category: "GCP Services", searchTerms: "gcp google cloud functions serverless" },
+  { type: "serverless", techStack: "GCP Cloud Run", category: "GCP Services", searchTerms: "gcp google cloud run serverless container" },
+  { type: "serverless", techStack: "GCP App Engine", category: "GCP Services", searchTerms: "gcp google app engine paas" },
+  // GCP Compute
+  { type: "compute", techStack: "GCP Compute Engine", category: "GCP Services", searchTerms: "gcp google compute engine vm instance" },
+  { type: "container", techStack: "GCP GKE", category: "GCP Services", searchTerms: "gcp google gke kubernetes k8s" },
+  // GCP Storage
+  { type: "storage", techStack: "GCP Cloud Storage", category: "GCP Services", searchTerms: "gcp google cloud storage bucket object" },
+  { type: "storage", techStack: "GCP Persistent Disk", category: "GCP Services", searchTerms: "gcp google persistent disk storage" },
+  // GCP Database
+  { type: "database", techStack: "GCP Cloud SQL", category: "GCP Services", searchTerms: "gcp google cloud sql database" },
+  { type: "database", techStack: "GCP Firestore", category: "GCP Services", searchTerms: "gcp google firestore database nosql" },
+  { type: "database", techStack: "GCP Bigtable", category: "GCP Services", searchTerms: "gcp google bigtable database nosql" },
+  { type: "database", techStack: "GCP Spanner", category: "GCP Services", searchTerms: "gcp google spanner database sql" },
+  { type: "database", techStack: "GCP BigQuery", category: "GCP Services", searchTerms: "gcp google bigquery data warehouse analytics" },
+  // GCP Messaging
+  { type: "queue", techStack: "GCP Pub/Sub", category: "GCP Services", searchTerms: "gcp google pubsub pub/sub message queue" },
+  // GCP CDN/Network
+  { type: "cdn", techStack: "GCP Cloud CDN", category: "GCP Services", searchTerms: "gcp google cloud cdn edge" },
+  { type: "cdn", techStack: "GCP Cloud DNS", category: "GCP Services", searchTerms: "gcp google cloud dns domain" },
+  { type: "cdn", techStack: "GCP Load Balancing", category: "GCP Services", searchTerms: "gcp google load balancing" },
+  // Azure Serverless
+  { type: "serverless", techStack: "Azure Functions", category: "Azure Services", searchTerms: "azure functions serverless" },
+  { type: "serverless", techStack: "Azure Logic Apps", category: "Azure Services", searchTerms: "azure logic apps workflow" },
+  { type: "serverless", techStack: "Azure API Management", category: "Azure Services", searchTerms: "azure api management gateway" },
+  // Azure Compute
+  { type: "compute", techStack: "Azure VM", category: "Azure Services", searchTerms: "azure vm virtual machine compute" },
+  { type: "container", techStack: "Azure AKS", category: "Azure Services", searchTerms: "azure aks kubernetes k8s" },
+  { type: "container", techStack: "Azure Container Instances", category: "Azure Services", searchTerms: "azure container instances aci" },
+  // Azure Storage
+  { type: "storage", techStack: "Azure Blob Storage", category: "Azure Services", searchTerms: "azure blob storage object" },
+  { type: "storage", techStack: "Azure Files", category: "Azure Services", searchTerms: "azure files storage file system" },
+  { type: "storage", techStack: "Azure Disk Storage", category: "Azure Services", searchTerms: "azure disk storage volume" },
+  // Azure Database
+  { type: "database", techStack: "Azure SQL", category: "Azure Services", searchTerms: "azure sql database" },
+  { type: "database", techStack: "Azure Cosmos DB", category: "Azure Services", searchTerms: "azure cosmos db database nosql" },
+  { type: "database", techStack: "Azure Database for PostgreSQL", category: "Azure Services", searchTerms: "azure postgresql database" },
+  { type: "database", techStack: "Azure Database for MySQL", category: "Azure Services", searchTerms: "azure mysql database" },
+  { type: "cache", techStack: "Azure Cache for Redis", category: "Azure Services", searchTerms: "azure redis cache" },
+  // Azure Messaging
+  { type: "queue", techStack: "Azure Service Bus", category: "Azure Services", searchTerms: "azure service bus queue message" },
+  { type: "queue", techStack: "Azure Event Hubs", category: "Azure Services", searchTerms: "azure event hubs stream" },
+  { type: "queue", techStack: "Azure Event Grid", category: "Azure Services", searchTerms: "azure event grid" },
+  { type: "queue", techStack: "Azure Queue Storage", category: "Azure Services", searchTerms: "azure queue storage message" },
+  // Azure CDN/Network
+  { type: "cdn", techStack: "Azure CDN", category: "Azure Services", searchTerms: "azure cdn edge" },
+  { type: "cdn", techStack: "Azure DNS", category: "Azure Services", searchTerms: "azure dns domain" },
+  { type: "cdn", techStack: "Azure Front Door", category: "Azure Services", searchTerms: "azure front door cdn" },
+  // Traditional Databases
+  { type: "database", techStack: "PostgreSQL", category: "Databases", searchTerms: "postgresql postgres sql database" },
+  { type: "database", techStack: "MySQL", category: "Databases", searchTerms: "mysql sql database" },
+  { type: "database", techStack: "MongoDB", category: "Databases", searchTerms: "mongodb mongo nosql database" },
+  { type: "database", techStack: "Redis", category: "Databases", searchTerms: "redis cache database key-value" },
+  { type: "database", techStack: "DynamoDB", category: "Databases", searchTerms: "dynamodb nosql database aws" },
+  { type: "database", techStack: "Cassandra", category: "Databases", searchTerms: "cassandra nosql database" },
+  { type: "database", techStack: "CouchDB", category: "Databases", searchTerms: "couchdb nosql database" },
+  { type: "database", techStack: "Elasticsearch", category: "Databases", searchTerms: "elasticsearch search database" },
+  { type: "database", techStack: "Neo4j", category: "Databases", searchTerms: "neo4j graph database" },
+  { type: "database", techStack: "InfluxDB", category: "Databases", searchTerms: "influxdb timeseries database" },
+  { type: "database", techStack: "TimescaleDB", category: "Databases", searchTerms: "timescaledb timeseries postgresql database" },
+  { type: "database", techStack: "MariaDB", category: "Databases", searchTerms: "mariadb mysql sql database" },
+  { type: "database", techStack: "SQLite", category: "Databases", searchTerms: "sqlite sql database" },
+  { type: "database", techStack: "Oracle", category: "Databases", searchTerms: "oracle sql database" },
+  { type: "database", techStack: "SQL Server", category: "Databases", searchTerms: "sql server mssql database microsoft" },
+  // Cache & In-Memory
+  { type: "cache", techStack: "Memcached", category: "Cache & In-Memory", searchTerms: "memcached cache memory" },
+  { type: "cache", techStack: "Hazelcast", category: "Cache & In-Memory", searchTerms: "hazelcast cache memory" },
+  { type: "cache", techStack: "Aerospike", category: "Cache & In-Memory", searchTerms: "aerospike cache database" },
+  // Message Queues
+  { type: "queue", techStack: "Kafka", category: "Message Queues", searchTerms: "kafka message queue stream" },
+  { type: "queue", techStack: "RabbitMQ", category: "Message Queues", searchTerms: "rabbitmq message queue amqp" },
+  { type: "queue", techStack: "SQS", category: "Message Queues", searchTerms: "sqs queue aws message" },
+  { type: "queue", techStack: "Redis Queue", category: "Message Queues", searchTerms: "redis queue message" },
+  { type: "queue", techStack: "NATS", category: "Message Queues", searchTerms: "nats message queue" },
+  { type: "queue", techStack: "Apache Pulsar", category: "Message Queues", searchTerms: "pulsar message queue stream" },
+  { type: "queue", techStack: "ActiveMQ", category: "Message Queues", searchTerms: "activemq message queue" },
+  { type: "queue", techStack: "ZeroMQ", category: "Message Queues", searchTerms: "zeromq zmq message queue" },
+  // External Systems
+  { type: "external", techStack: "Third Party API", category: "External Systems", searchTerms: "third party api external" },
+  { type: "external", techStack: "Payment Gateway", category: "External Systems", searchTerms: "payment gateway stripe paypal" },
+  { type: "external", techStack: "Auth Service", category: "External Systems", searchTerms: "auth authentication authorization" },
+  { type: "external", techStack: "Email Service", category: "External Systems", searchTerms: "email service sendgrid mailgun" },
+  { type: "external", techStack: "SMS Service", category: "External Systems", searchTerms: "sms service twilio" },
+  { type: "external", techStack: "Analytics Service", category: "External Systems", searchTerms: "analytics service google analytics" },
+  // Text & Annotations
+  { type: "text", techStack: "Text Note", category: "Annotations", searchTerms: "text note annotation comment label" },
+  { type: "text", techStack: "Sticky Note", category: "Annotations", searchTerms: "sticky note annotation comment" },
+  { type: "text", techStack: "Comment", category: "Annotations", searchTerms: "comment annotation note text" },
+  // Grouping
+  { type: "group", techStack: "Logical Group", category: "Grouping", searchTerms: "group container boundary logical" },
+  { type: "group", techStack: "Network Boundary", category: "Grouping", searchTerms: "group network boundary vpc subnet" },
+  { type: "group", techStack: "Security Zone", category: "Grouping", searchTerms: "group security zone boundary" },
+  { type: "group", techStack: "Service Group", category: "Grouping", searchTerms: "group service container boundary" }
+];
+
+// ../frontend/src/dsl/lexer.ts
+var IDENT_START = /[A-Za-z_]/;
+var IDENT_PART = /[A-Za-z0-9_]/;
+var TEAM_PART = /[A-Za-z0-9_-]/;
+var DIGIT = /[0-9]/;
+function tokenizeLine(text, line) {
+  const tokens = [];
+  const diagnostics = [];
+  let i = 0;
+  const error = (message, col, length) => diagnostics.push({ severity: "error", message, line, col, length });
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === " " || ch === "	" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (ch === "#") break;
+    const start = i;
+    if (ch === ":") {
+      const raw = stripTrailingComment(text.slice(i + 1));
+      tokens.push({ kind: "label", value: raw.trim(), col: start + 1, length: text.length - start });
+      break;
+    }
+    if (ch === '"') {
+      const { value, end, closed } = readString(text, i);
+      if (!closed) error("Unterminated string", start + 1, text.length - start);
+      tokens.push({ kind: "string", value, col: start + 1, length: end - start });
+      i = end;
+      continue;
+    }
+    if (ch === "[") {
+      const close = text.indexOf("]", i + 1);
+      if (close === -1) {
+        error("Missing ] after tech stack", start + 1, text.length - start);
+        tokens.push({ kind: "tech", value: text.slice(i + 1).trim(), col: start + 1, length: text.length - start });
+        break;
+      }
+      tokens.push({ kind: "tech", value: text.slice(i + 1, close).trim(), col: start + 1, length: close + 1 - start });
+      i = close + 1;
+      continue;
+    }
+    if (ch === "-") {
+      const arrow = ["->>", "-->", "->"].find((a) => text.startsWith(a, i));
+      const failed = text.startsWith("-x", i) && !IDENT_PART.test(text[i + 2] ?? "");
+      if (arrow || failed) {
+        const value = arrow ?? "-x";
+        tokens.push({ kind: "arrow", value, col: start + 1, length: value.length });
+        i += value.length;
+        continue;
+      }
+      if (DIGIT.test(text[i + 1] ?? "")) {
+        i++;
+        while (i < text.length && DIGIT.test(text[i])) i++;
+        tokens.push({ kind: "number", value: text.slice(start, i), col: start + 1, length: i - start });
+        continue;
+      }
+    }
+    if (DIGIT.test(ch)) {
+      while (i < text.length && DIGIT.test(text[i])) i++;
+      tokens.push({ kind: "number", value: text.slice(start, i), col: start + 1, length: i - start });
+      continue;
+    }
+    if (ch === "@") {
+      i++;
+      while (i < text.length && TEAM_PART.test(text[i])) i++;
+      if (i === start + 1) error("Expected a team name after @", start + 1, 1);
+      tokens.push({ kind: "team", value: text.slice(start + 1, i), col: start + 1, length: i - start });
+      continue;
+    }
+    if (IDENT_START.test(ch)) {
+      while (i < text.length && IDENT_PART.test(text[i])) i++;
+      tokens.push({ kind: "ident", value: text.slice(start, i), col: start + 1, length: i - start });
+      continue;
+    }
+    if (ch === "{" || ch === "}" || ch === ",") {
+      const kind = ch === "{" ? "lbrace" : ch === "}" ? "rbrace" : "comma";
+      tokens.push({ kind, value: ch, col: start + 1, length: 1 });
+      i++;
+      continue;
+    }
+    error(`Unexpected character '${ch}'`, start + 1, 1);
+    i++;
+  }
+  return { tokens, diagnostics };
+}
+function readString(text, start) {
+  let value = "";
+  let i = start + 1;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\" && i + 1 < text.length) {
+      value += text[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === '"') return { value, end: i + 1, closed: true };
+    value += ch;
+    i++;
+  }
+  return { value, end: text.length, closed: false };
+}
+function stripTrailingComment(text) {
+  let depth = 0;
+  let quote = null;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"') quote = ch;
+    else if (ch === "{" || ch === "[") depth++;
+    else if (ch === "}" || ch === "]") depth = Math.max(0, depth - 1);
+    else if (ch === "#" && depth === 0 && (i === 0 || /\s/.test(text[i - 1]))) return text.slice(0, i);
+  }
+  return text;
+}
+function bracketDepth(text) {
+  let depth = 0;
+  let inString = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === "\\") i++;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{" || ch === "[") depth++;
+    else if (ch === "}" || ch === "]") depth--;
+  }
+  return depth;
+}
+
+// ../frontend/src/dsl/parser.ts
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+var DEFAULT_TECH = "Rectangle";
+var DEFAULT_GROUP_TECH = "Logical Group";
+var MAX_SCENARIOS = 32;
+var techByName = new Map(
+  componentCatalog.map((c) => [c.techStack.toLowerCase(), { type: c.type, techStack: c.techStack }])
+);
+function parse(source) {
+  return new Parser(source).run();
+}
+var Parser = class {
+  lines;
+  diagnostics = [];
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  useCases = [];
+  references = [];
+  stack = [];
+  title;
+  constructor(source) {
+    this.lines = source.split("\n");
+  }
+  run() {
+    for (let i = 0; i < this.lines.length; i++) {
+      i = this.parseLine(i);
+    }
+    for (const frame of this.stack) {
+      const what = frame.kind === "group" ? `group '${frame.id}'` : frame.kind === "usecase" ? `usecase '${frame.useCase.name}'` : frame.kind === "alt" ? `alt '${frame.name}'` : "par block";
+      this.error(`Missing } to close ${what}`, frame.loc);
+    }
+    this.createImplicitNodes();
+    const diagram = {
+      title: this.title,
+      nodes: [...this.nodes.values()],
+      edges: this.edges,
+      useCases: this.useCases.map(({ useCase, body }) => this.buildUseCase(useCase, body))
+    };
+    this.diagnostics.sort((a, b) => a.line - b.line || a.col - b.col);
+    return { diagram, diagnostics: this.diagnostics };
+  }
+  /** Parses the line at `index` and returns the index of the last line it consumed. */
+  parseLine(index) {
+    const line = index + 1;
+    const { tokens, diagnostics } = tokenizeLine(this.lines[index], line);
+    this.diagnostics.push(...diagnostics);
+    if (tokens.length === 0 || diagnostics.some((d) => d.severity === "error")) return index;
+    const [first, second] = tokens;
+    const loc = (t) => ({ line, col: t.col, length: t.length });
+    if (first.kind === "rbrace") {
+      if (this.stack.length === 0) this.error("Unmatched }", loc(first));
+      else this.closeFrame();
+      if (second?.kind === "ident" && second.value === "alt") this.parseAlt(tokens.slice(1), line);
+      else if (second) this.error("Unexpected input after }", loc(second));
+      return index;
+    }
+    if (first.kind === "ident" && second?.kind === "arrow") {
+      return this.parseConnection(tokens, index);
+    }
+    if (first.kind !== "ident") {
+      this.error("Expected a node, connection, group or usecase", loc(first));
+      return index;
+    }
+    switch (first.value) {
+      case "title":
+        this.parseTitle(tokens, line);
+        break;
+      case "group":
+        this.parseGroup(tokens, line);
+        break;
+      case "usecase":
+        this.parseUseCase(tokens, line);
+        break;
+      case "par":
+        this.parsePar(tokens, line);
+        break;
+      case "alt":
+        this.parseAlt(tokens, line);
+        break;
+      default:
+        this.parseNode(tokens, line);
+    }
+    return index;
+  }
+  parseTitle(tokens, line) {
+    const value = tokens[1];
+    if (!value || value.kind !== "string" && value.kind !== "ident") {
+      this.error('Expected a title, e.g. title "My System"', this.locOf(tokens[0], line));
+      return;
+    }
+    this.title = value.value;
+    this.expectEnd(tokens, 2, line);
+  }
+  parseGroup(tokens, line) {
+    const keyword = tokens[0];
+    const top = this.top();
+    if (top && top.kind !== "group") {
+      this.error("Groups cannot be declared inside a usecase", this.locOf(keyword, line));
+      return;
+    }
+    const idToken = tokens[1];
+    if (idToken?.kind !== "ident") {
+      this.error('Expected a group id, e.g. group vpc "AWS VPC" {', this.locOf(keyword, line));
+      return;
+    }
+    let i = 2;
+    let name = idToken.value;
+    let techStack = DEFAULT_GROUP_TECH;
+    if (tokens[i]?.kind === "string") name = tokens[i++].value;
+    if (tokens[i]?.kind === "tech") {
+      const tech = tokens[i++];
+      const resolved = this.resolveTech(tech, line);
+      if (resolved.type === "group") techStack = resolved.techStack;
+      else this.warning(`'${tech.value}' is not a group style; using ${DEFAULT_GROUP_TECH}`, this.locOf(tech, line));
+    }
+    let position;
+    if (tokens[i]?.kind === "ident" && tokens[i].value === "pos") {
+      const [x, comma, y] = [tokens[i + 1], tokens[i + 2], tokens[i + 3]];
+      if (x?.kind !== "number" || comma?.kind !== "comma" || y?.kind !== "number") {
+        this.error("Expected pos x,y", this.locOf(tokens[i], line));
+        return;
+      }
+      position = { x: Number(x.value), y: Number(y.value) };
+      i += 4;
+    }
+    if (tokens[i]?.kind !== "lbrace") {
+      this.error("Expected { after group header", this.locOf(tokens[i] ?? tokens[i - 1], line));
+      return;
+    }
+    this.expectEnd(tokens, i + 1, line);
+    const loc = this.locOf(idToken, line);
+    this.addNode({ id: idToken.value, kind: "group", name, type: "group", techStack, parent: this.currentGroup(), position, loc });
+    this.stack.push({ kind: "group", id: idToken.value, loc });
+  }
+  parseUseCase(tokens, line) {
+    const keyword = tokens[0];
+    if (this.stack.length > 0) {
+      this.error("A usecase must be declared at the top level", this.locOf(keyword, line));
+      return;
+    }
+    const nameToken = tokens[1];
+    if (nameToken?.kind !== "string" && nameToken?.kind !== "ident") {
+      this.error('Expected a usecase name, e.g. usecase "Place order" {', this.locOf(keyword, line));
+      return;
+    }
+    let i = 2;
+    let description;
+    if (tokens[i]?.kind === "string") description = tokens[i++].value;
+    if (tokens[i]?.kind !== "lbrace") {
+      this.error("Expected { after usecase name", this.locOf(tokens[i] ?? tokens[i - 1], line));
+      return;
+    }
+    this.expectEnd(tokens, i + 1, line);
+    const loc = this.locOf(nameToken, line);
+    const useCase = { id: this.useCaseId(nameToken.value), name: nameToken.value, description, steps: [], scenarios: [], loc };
+    const frame = { kind: "usecase", useCase, body: { items: [] }, parCount: 0, loc };
+    this.useCases.push({ useCase, body: frame.body });
+    this.stack.push(frame);
+  }
+  parseAlt(tokens, line) {
+    const keyword = tokens[0];
+    const top = this.top();
+    if (top?.kind !== "usecase" && top?.kind !== "alt") {
+      this.error(top?.kind === "par" ? "alt blocks cannot be inside a par block" : "alt is only allowed inside a usecase", this.locOf(keyword, line));
+      return;
+    }
+    const nameToken = tokens[1];
+    if (nameToken?.kind !== "string" && nameToken?.kind !== "ident") {
+      this.error('Expected a scenario name, e.g. alt "Not found" {', this.locOf(keyword, line));
+      return;
+    }
+    if (tokens[2]?.kind !== "lbrace") {
+      this.error("Expected { after alt name", this.locOf(tokens[2] ?? nameToken, line));
+      return;
+    }
+    this.expectEnd(tokens, 3, line);
+    const owner = top.body;
+    let set = owner.openAlt;
+    if (!set) {
+      set = { kind: "alt", branches: [] };
+      owner.items.push(set);
+    }
+    const loc = this.locOf(nameToken, line);
+    if (set.branches.some((b) => b.name === nameToken.value)) this.warning(`Duplicate alt name '${nameToken.value}'`, loc);
+    const body = { items: [] };
+    set.branches.push({ name: nameToken.value, items: body.items, loc });
+    owner.openAlt = void 0;
+    this.stack.push({ kind: "alt", name: nameToken.value, body, owner, set, loc });
+  }
+  closeFrame() {
+    const frame = this.stack.pop();
+    if (frame?.kind === "alt") frame.owner.openAlt = frame.set;
+  }
+  parsePar(tokens, line) {
+    const keyword = tokens[0];
+    const top = this.top();
+    if (top?.kind !== "usecase" && top?.kind !== "alt") {
+      this.error(top?.kind === "par" ? "par blocks cannot be nested" : "par is only allowed inside a usecase", this.locOf(keyword, line));
+      return;
+    }
+    if (tokens[1]?.kind !== "lbrace") {
+      this.error("Expected { after par", this.locOf(tokens[1] ?? keyword, line));
+      return;
+    }
+    this.expectEnd(tokens, 2, line);
+    top.body.openAlt = void 0;
+    const useCase = this.currentUseCase();
+    useCase.parCount++;
+    this.stack.push({ kind: "par", group: useCase.parCount, loc: this.locOf(keyword, line) });
+  }
+  parseNode(tokens, line) {
+    const idToken = tokens[0];
+    const loc = this.locOf(idToken, line);
+    if (this.inUseCase()) {
+      this.error("Declare nodes outside usecase blocks; steps look like a -> b : label", loc);
+      return;
+    }
+    const node = { id: idToken.value, kind: "component", name: idToken.value, type: "shape", techStack: DEFAULT_TECH, parent: this.currentGroup(), loc };
+    let strings = 0;
+    for (let i = 1; i < tokens.length; i++) {
+      const t = tokens[i];
+      if (t.kind === "string" && strings < 2) {
+        if (strings++ === 0) node.name = t.value;
+        else node.description = t.value;
+      } else if (t.kind === "tech") {
+        const resolved = this.resolveTech(t, line);
+        node.type = resolved.type;
+        node.techStack = resolved.techStack;
+        node.kind = resolved.type === "text" ? "text" : resolved.type === "group" ? "group" : "component";
+      } else if (t.kind === "team") {
+        node.ownerTeam = t.value;
+      } else if (t.kind === "ident" && t.value === "pos") {
+        const [x, comma, y] = [tokens[i + 1], tokens[i + 2], tokens[i + 3]];
+        if (x?.kind !== "number" || comma?.kind !== "comma" || y?.kind !== "number") {
+          this.error("Expected pos x,y", this.locOf(t, line));
+          return;
+        }
+        node.position = { x: Number(x.value), y: Number(y.value) };
+        i += 3;
+      } else if (t.kind === "label" || t.kind === "arrow") {
+        this.error(`Expected '${idToken.value} -> target' for a connection`, this.locOf(t, line));
+        return;
+      } else {
+        this.error(`Unexpected ${describe(t)} in node declaration`, this.locOf(t, line));
+        return;
+      }
+    }
+    this.addNode(node);
+  }
+  parseConnection(tokens, index) {
+    const line = index + 1;
+    const [fromToken, arrowToken, toToken, labelToken] = tokens;
+    if (toToken?.kind !== "ident") {
+      this.error("Expected a target id after the arrow", this.locOf(toToken ?? arrowToken, line));
+      return index;
+    }
+    if (tokens.length > 4 || labelToken && labelToken.kind !== "label") {
+      this.error("Expected : before the connection label", this.locOf(labelToken, line));
+      return index;
+    }
+    let label = labelToken?.value ?? "";
+    let lastLine = index;
+    if (bracketDepth(label) > 0) {
+      while (bracketDepth(label) > 0 && lastLine + 1 < this.lines.length) {
+        lastLine++;
+        label += "\n" + this.lines[lastLine];
+      }
+      if (bracketDepth(label) > 0) this.error("Unclosed { or [ in payload", this.locOf(labelToken, line));
+      label = label.trimEnd();
+    }
+    const loc = { line, col: fromToken.col, length: (labelToken ?? toToken).col + (labelToken ?? toToken).length - fromToken.col };
+    const from = fromToken.value;
+    const to = toToken.value;
+    const arrow = arrowToken.value;
+    this.references.push({ id: from, loc: this.locOf(fromToken, line) }, { id: to, loc: this.locOf(toToken, line) });
+    const top = this.top();
+    if (top?.kind === "usecase" || top?.kind === "alt" || top?.kind === "par") {
+      const body = this.currentBody();
+      body.openAlt = void 0;
+      body.items.push({ kind: "step", step: { from, to, arrow, label, parallelGroup: top.kind === "par" ? top.group : void 0, loc } });
+    } else if (arrow === "-x") {
+      this.error("'-x' marks a failed call and is only allowed in use case steps", this.locOf(arrowToken, line));
+    } else {
+      const base = `${from}->${to}`;
+      const count = this.edges.filter((e) => e.id === base || e.id.startsWith(`${base}#`)).length;
+      this.edges.push({ id: count ? `${base}#${count + 1}` : base, source: from, target: to, label: unquote(label) || void 0, loc });
+    }
+    return lastLine;
+  }
+  buildUseCase(useCase, body) {
+    let paths = expand(body.items);
+    if (paths.length > MAX_SCENARIOS) {
+      this.warning(`Too many scenarios (${paths.length}); only the first ${MAX_SCENARIOS} are kept`, useCase.loc);
+      paths = paths.slice(0, MAX_SCENARIOS);
+    }
+    const taken = /* @__PURE__ */ new Set();
+    const scenarios = paths.map((path) => {
+      const base = path.names.length ? slug(path.names.join(" ")) || "scenario" : "main";
+      let id = base;
+      for (let n = 2; taken.has(id); n++) id = `${base}-${n}`;
+      taken.add(id);
+      const steps2 = this.buildSteps(useCase.id, id, path.steps);
+      const entry2 = steps2[0];
+      const failedEntry = !!entry2 && (entry2.failed || (entry2.statusCode ?? 0) >= 400);
+      return {
+        id,
+        name: path.names.length ? path.names.join(" \u203A ") : useCase.name,
+        outcome: failedEntry ? "error" : "success",
+        steps: steps2,
+        loc: path.locs.at(-1) ?? useCase.loc
+      };
+    });
+    const steps = scenarios[0]?.steps ?? [];
+    const entry = steps[0];
+    return {
+      ...useCase,
+      entryServiceId: entry?.fromServiceId,
+      endpoint: entry?.httpMethod ? `${entry.httpMethod} ${entry.endpoint}` : void 0,
+      steps,
+      scenarios
+    };
+  }
+  buildSteps(useCaseId, scenarioId, raw) {
+    const steps = [];
+    const answered = /* @__PURE__ */ new Set();
+    const prefix = scenarioId === "main" ? useCaseId : `${useCaseId}-${scenarioId}`;
+    for (const step of raw) {
+      if (step.arrow === "-->") {
+        const request = [...steps].reverse().find((s) => s.fromServiceId === step.to && s.toServiceId === step.from && !answered.has(s) && !s.failed);
+        if (!request) {
+          this.warning(`Response has no matching request from '${step.to}' to '${step.from}'`, step.loc);
+          continue;
+        }
+        answered.add(request);
+        const status = step.label.match(/^(\d{3})\b\s*([\s\S]*)$/);
+        if (status) request.statusCode = Number(status[1]);
+        const payload = splitPayload(status ? status[2] : step.label);
+        const body = payload.body ?? payload.text;
+        if (body) {
+          request.responseBody = body;
+          request.responseFormat = payload.body ? payload.format : "FREE_TEXT";
+        }
+        if (request.executionType === "ASYNC_FIRE_AND_FORGET") request.executionType = "ASYNC_REQUEST_RESPONSE";
+        continue;
+      }
+      const label = parseStepLabel(step.label);
+      const target = this.nodes.get(step.to);
+      const isAsync = step.arrow === "->>";
+      steps.push({
+        id: `${prefix}-${steps.length + 1}`,
+        stepOrder: steps.length,
+        stepName: label.name || `${step.from} \u2192 ${step.to}`,
+        fromServiceId: step.from,
+        toServiceId: step.to,
+        protocol: inferProtocol(isAsync, label.method, target),
+        httpMethod: label.method ?? "",
+        endpoint: label.endpoint ?? "",
+        requestFormat: label.format ?? "JSON",
+        requestBody: label.body,
+        responseFormat: "JSON",
+        description: label.description,
+        executionType: isAsync ? "ASYNC_FIRE_AND_FORGET" : "SYNC_REQUEST_RESPONSE",
+        parallelGroup: step.parallelGroup,
+        isParallel: step.parallelGroup !== void 0,
+        isConditional: false,
+        ...step.arrow === "-x" ? { failed: true } : {}
+      });
+    }
+    return steps;
+  }
+  createImplicitNodes() {
+    for (const ref of this.references) {
+      if (this.nodes.has(ref.id)) continue;
+      this.nodes.set(ref.id, { id: ref.id, kind: "component", name: ref.id, type: "shape", techStack: DEFAULT_TECH, implicit: true, loc: ref.loc });
+    }
+  }
+  addNode(node) {
+    const existing = this.nodes.get(node.id);
+    if (existing) {
+      this.error(`Duplicate id '${node.id}' (first declared on line ${existing.loc.line})`, node.loc);
+      return;
+    }
+    this.nodes.set(node.id, node);
+  }
+  resolveTech(token, line) {
+    const resolved = techByName.get(token.value.toLowerCase());
+    if (resolved) return resolved;
+    this.warning(`Unknown tech stack '${token.value}'; drawing a ${DEFAULT_TECH}`, this.locOf(token, line));
+    return { type: "shape", techStack: DEFAULT_TECH };
+  }
+  useCaseId(name) {
+    const base = slug(name) || "usecase";
+    const taken = new Set(this.useCases.map((u) => u.useCase.id));
+    let id = base;
+    for (let n = 2; taken.has(id); n++) id = `${base}-${n}`;
+    return id;
+  }
+  top() {
+    return this.stack[this.stack.length - 1];
+  }
+  currentGroup() {
+    const top = this.top();
+    return top?.kind === "group" ? top.id : void 0;
+  }
+  currentUseCase() {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const frame = this.stack[i];
+      if (frame.kind === "usecase") return frame;
+    }
+    return void 0;
+  }
+  currentBody() {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const frame = this.stack[i];
+      if (frame.kind === "usecase" || frame.kind === "alt") return frame.body;
+    }
+    return void 0;
+  }
+  inUseCase() {
+    return this.currentUseCase() !== void 0;
+  }
+  expectEnd(tokens, from, line) {
+    if (tokens.length > from) this.error(`Unexpected ${describe(tokens[from])}`, this.locOf(tokens[from], line));
+  }
+  locOf(token, line) {
+    return token ? { line, col: token.col, length: token.length } : { line, col: 1, length: 1 };
+  }
+  error(message, loc) {
+    this.diagnostics.push({ severity: "error", message, ...loc });
+  }
+  warning(message, loc) {
+    if (this.diagnostics.some((d) => d.message === message && d.line === loc.line && d.col === loc.col)) return;
+    this.diagnostics.push({ severity: "warning", message, ...loc });
+  }
+};
+function expand(items) {
+  let paths = [{ names: [], locs: [], steps: [] }];
+  for (const item of items) {
+    if (item.kind === "step") {
+      for (const path of paths) path.steps.push(item.step);
+      continue;
+    }
+    const next = [];
+    for (const path of paths) {
+      for (const branch of item.branches) {
+        for (const sub of expand(branch.items)) {
+          next.push({
+            names: [...path.names, branch.name, ...sub.names],
+            locs: [...path.locs, branch.loc, ...sub.locs],
+            steps: [...path.steps, ...sub.steps]
+          });
+        }
+      }
+      if (next.length > MAX_SCENARIOS * 4) break;
+    }
+    paths = next;
+  }
+  return paths;
+}
+function slug(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function splitPayload(input) {
+  const text = input.trim();
+  const formats = { json: "JSON", xml: "XML", text: "FREE_TEXT" };
+  const leading = text.match(/^(json|xml|text)\s+([\s\S]+)$/i);
+  if (leading) return { text: "", format: formats[leading[1].toLowerCase()], body: leading[2].trim() };
+  const keyed = text.match(/^([\s\S]*?)\s+(json|xml)\s+([{[<][\s\S]*)$/i);
+  if (keyed) return { text: keyed[1].trim(), format: formats[keyed[2].toLowerCase()], body: keyed[3].trim() };
+  const bare = text.search(/(^|\s)[{[<]/);
+  if (bare !== -1) {
+    const body = text.slice(bare).trim();
+    return { text: text.slice(0, bare).trim(), format: body.startsWith("<") ? "XML" : "JSON", body };
+  }
+  return { text: unquote(text), format: "JSON" };
+}
+function parseStepLabel(input) {
+  const http = input.trim().match(/^([A-Z]+)\s+(\S+)\s*([\s\S]*)$/);
+  if (http && HTTP_METHODS.includes(http[1])) {
+    const payload2 = splitPayload(http[3]);
+    return {
+      name: `${http[1]} ${http[2]}`,
+      method: http[1],
+      endpoint: http[2],
+      description: payload2.text || void 0,
+      format: payload2.body ? payload2.format : void 0,
+      body: payload2.body
+    };
+  }
+  const payload = splitPayload(input);
+  return { name: payload.text, format: payload.body ? payload.format : void 0, body: payload.body };
+}
+function inferProtocol(isAsync, method, target) {
+  if (isAsync || target?.type === "queue") return "MESSAGING";
+  if (!method) return "OTHER";
+  switch (target?.techStack) {
+    case "GraphQL":
+      return "GRAPHQL";
+    case "gRPC":
+      return "GRPC";
+    case "SOAP API":
+      return "SOAP";
+    default:
+      return "REST";
+  }
+}
+function unquote(text) {
+  const t = text.trim();
+  return t.length >= 2 && t.startsWith('"') && t.endsWith('"') ? t.slice(1, -1) : t;
+}
+function describe(token) {
+  switch (token.kind) {
+    case "string":
+      return `string "${token.value}"`;
+    case "tech":
+      return `[${token.value}]`;
+    case "team":
+      return `@${token.value}`;
+    case "label":
+      return "':'";
+    case "lbrace":
+    case "rbrace":
+    case "comma":
+    case "arrow":
+      return `'${token.value}'`;
+    default:
+      return `'${token.value}'`;
+  }
+}
+
+// src/cli.ts
+var VERSION = true ? "0.1.0" : "dev";
+var USAGE = `Usage:
+  proschi check [--strict] [--format text|github|json] <file|dir>...
+  proschi parse <file>
+  proschi --version
+
+check   Reports errors and warnings. Directories are searched for *.proschi files.
+        Exits with 1 if any file has an error (or a warning, with --strict).
+parse   Prints {"diagram", "diagnostics"} as JSON; the shape is described by
+        schema/proschi-diagram.schema.json.`;
+function collectFiles(paths) {
+  const out = [];
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs.readdirSync)(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = (0, import_node_path.join)(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.name.endsWith(".proschi")) out.push(full);
+    }
+  };
+  for (const p of paths) {
+    if ((0, import_node_fs.statSync)(p).isDirectory()) walk(p);
+    else out.push(p);
+  }
+  return out;
+}
+function displayPath(file) {
+  const rel = (0, import_node_path.relative)(process.cwd(), file);
+  return rel && !rel.startsWith("..") && !(0, import_node_path.isAbsolute)(rel) ? rel : file;
+}
+function format(results, style) {
+  if (style === "json") return JSON.stringify(results, null, 2);
+  const lines = [];
+  for (const { file, diagnostics } of results) {
+    for (const d of diagnostics) {
+      if (style === "github") {
+        const level = d.severity === "error" ? "error" : "warning";
+        lines.push(`::${level} file=${file},line=${d.line},col=${d.col},title=proschi::${d.message.replace(/%/g, "%25").replace(/\r?\n/g, "%0A")}`);
+      } else {
+        lines.push(`${file}:${d.line}:${d.col}: ${d.severity}: ${d.message}`);
+      }
+    }
+  }
+  if (style === "text") {
+    const errors = results.reduce((n, r) => n + r.diagnostics.filter((d) => d.severity === "error").length, 0);
+    const warnings = results.reduce((n, r) => n + r.diagnostics.filter((d) => d.severity === "warning").length, 0);
+    const files = results.length === 1 ? "1 file" : `${results.length} files`;
+    lines.push(errors || warnings ? `${files}: ${errors} error(s), ${warnings} warning(s)` : `${files}: no problems`);
+  }
+  return lines.join("\n");
+}
+function run(argv, out = console.log, err = console.error) {
+  const [command, ...rest] = argv;
+  if (command === "--version" || command === "-v") {
+    out(VERSION);
+    return 0;
+  }
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    out(USAGE);
+    return command ? 0 : 2;
+  }
+  if (command === "parse") {
+    if (rest.length !== 1) {
+      err(USAGE);
+      return 2;
+    }
+    out(JSON.stringify(parse((0, import_node_fs.readFileSync)(rest[0], "utf8")), null, 2));
+    return 0;
+  }
+  if (command === "check") {
+    let strict = false;
+    let style = "text";
+    const paths = [];
+    for (let i = 0; i < rest.length; i++) {
+      const arg = rest[i];
+      if (arg === "--strict") strict = true;
+      else if (arg === "--format") {
+        const value = rest[++i];
+        if (value !== "text" && value !== "github" && value !== "json") {
+          err(`Unknown format '${value ?? ""}'; use text, github or json`);
+          return 2;
+        }
+        style = value;
+      } else if (arg.startsWith("-")) {
+        err(`Unknown option ${arg}
+
+${USAGE}`);
+        return 2;
+      } else paths.push(arg);
+    }
+    if (paths.length === 0) {
+      err(USAGE);
+      return 2;
+    }
+    let files;
+    try {
+      files = collectFiles(paths);
+    } catch (e) {
+      err(String(e.message));
+      return 2;
+    }
+    const results = files.map((file) => ({
+      file: displayPath(file),
+      diagnostics: parse((0, import_node_fs.readFileSync)(file, "utf8")).diagnostics
+    }));
+    const text = format(results, style);
+    if (text) out(text);
+    const failed = results.some((r) => r.diagnostics.some((d) => d.severity === "error" || strict));
+    return failed ? 1 : 0;
+  }
+  err(`Unknown command '${command}'
+
+${USAGE}`);
+  return 2;
+}
+if (true) process.exitCode = run(process.argv.slice(2));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectFiles,
+  format,
+  run
+});