@qualisoft/ai-skills 1.0.0

package/skills/erd-visual/fixtures/edge-cases.dbml

@@ -0,0 +1,43 @@
+// 회귀용 익명 샘플 ② — 깨지기 쉬운 것만 모았다.
+//   · 자기참조 · 그룹이 하나뿐인 경우 · 그룹에 안 들어간 테이블
+//   · 아주 긴 이름(자르기) · 관계가 하나도 없는 고립 테이블
+//   · 정의 없는 참조 대상(스텁) · 이름에 특수문자
+
+Table a_very_long_table_name_that_will_not_fit_in_a_card {
+  id uniqueidentifier [pk, not null, note: '기본 키']
+  parent_id uniqueidentifier [note: '자기참조 → a_very_long_table_name_that_will_not_fit_in_a_card']
+  Note: '아주 긴 이름을 가진 테이블이라 카드 폭에 절대 안 들어간다 (LongName) · 커스텀 · 총 속성 12개 · 표시 2개'
+}
+
+Table lonely {
+  lonely_id uniqueidentifier [pk, not null, note: '기본 키']
+  Note: '고립 테이블 — 관계가 하나도 없다 (Lonely) · 표준 · 총 속성 1개 · 표시 1개'
+}
+
+Table quoted_note {
+  id uniqueidentifier [pk, not null, note: '따옴표 \'테스트\' 포함']
+  target_id uniqueidentifier [note: '스텁 → ghost_table']
+  Note: '노트에 따옴표가 있는 테이블 (Quoted) · 표준 · 총 속성 2개 · 표시 2개'
+}
+
+Table ghost_table {
+  ghost_tableid uniqueidentifier [pk, note: '기본 키 (추정 — 문서에 없음)']
+  Note: '문서 밖 엔티티 · 이 문서에 정의 없음 · 피참조 1건'
+}
+
+Table ungrouped {
+  ungrouped_id uniqueidentifier [pk, not null, note: '기본 키']
+  long_ref uniqueidentifier [note: '긴 이름 → a_very_long_table_name_that_will_not_fit_in_a_card']
+  Note: '그룹에 안 들어간 테이블 (Ungrouped) · 표준 · 총 속성 2개 · 표시 2개'
+}
+
+TableGroup "유일한 그룹" {
+  a_very_long_table_name_that_will_not_fit_in_a_card
+  lonely
+  quoted_note
+  ghost_table
+}
+
+Ref: a_very_long_table_name_that_will_not_fit_in_a_card.parent_id > a_very_long_table_name_that_will_not_fit_in_a_card.id
+Ref: quoted_note.target_id > ghost_table.ghost_tableid
+Ref: ungrouped.long_ref > a_very_long_table_name_that_will_not_fit_in_a_card.id

package/skills/erd-visual/fixtures/map-dynamics.json

@@ -0,0 +1,32 @@
+{
+  "_설명": [
+    "Dynamics 365 자료 매핑. 파일 확장자별로 갈라 쓴다.",
+    "xlsx: 관계 근거는 Metadata 시트 L열(Additional data)의 'Targets:' 값.",
+    "      대상이 하나면 사실(Ref), 여럿이면 다형 참조라 선을 긋지 않는다.",
+    "xml : SiteMap 은 테이블이 아니라 '어느 엔티티가 어느 업무 영역인가'를 준다.",
+    "      그룹이 배선 품질과 속도를 좌우하므로 이 힌트가 중요하다."
+  ],
+
+  "entities": {
+    "sheet": "Entities list",
+    "name": "E",
+    "label": "A"
+  },
+  "attributes": {
+    "sheet": "Metadata",
+    "table": "B",
+    "name": "C",
+    "type": "F",
+    "label": "E",
+    "required": "J",
+    "extra": "L",
+    "refPattern": "Targets:\\s*(.*)"
+  },
+
+  "groups": {
+    "container": "Area",
+    "containerName": "Id",
+    "member": "SubArea",
+    "memberEntity": "Entity"
+  }
+}

package/skills/erd-visual/fixtures/shop-basic.dbml

@@ -0,0 +1,78 @@
+// 회귀용 익명 샘플 ① — 작은 커머스 스키마. 그룹 3개.
+// 검증기가 정상 동작하는지 보는 최소 케이스다.
+
+Table customer {
+  customer_id uniqueidentifier [pk, not null, note: '고객 ID']
+  name nvarchar(80) [not null, note: '고객명']
+  email nvarchar(160) [note: '이메일']
+  Note: '고객 (Customer) · 표준 · 총 속성 6개 · 표시 3개'
+}
+
+Table address {
+  address_id uniqueidentifier [pk, not null, note: '주소 ID']
+  customer_id uniqueidentifier [not null, note: '고객 → customer']
+  line1 nvarchar(200) [note: '도로명']
+  Note: '배송지 (Address) · 표준 · 총 속성 7개 · 표시 3개'
+}
+
+Table product {
+  product_id uniqueidentifier [pk, not null, note: '상품 ID']
+  name nvarchar(160) [not null, note: '상품명']
+  category_id uniqueidentifier [note: '분류 → category']
+  Note: '상품 (Product) · 표준 · 총 속성 9개 · 표시 3개'
+}
+
+Table category {
+  category_id uniqueidentifier [pk, not null, note: '분류 ID']
+  name nvarchar(80) [not null, note: '분류명']
+  parent_id uniqueidentifier [note: '상위 분류 → category']
+  Note: '분류 (Category) · 표준 · 총 속성 4개 · 표시 3개'
+}
+
+Table orders {
+  order_id uniqueidentifier [pk, not null, note: '주문 ID']
+  customer_id uniqueidentifier [not null, note: '고객 → customer']
+  address_id uniqueidentifier [note: '배송지 → address']
+  placed_at datetime [not null, note: '주문일시']
+  Note: '주문 (Orders) · 표준 · 총 속성 11개 · 표시 4개'
+}
+
+Table order_line {
+  order_line_id uniqueidentifier [pk, not null, note: '주문상세 ID']
+  order_id uniqueidentifier [not null, note: '주문 → orders']
+  product_id uniqueidentifier [not null, note: '상품 → product']
+  qty int [not null, note: '수량']
+  Note: '주문 상세 (OrderLine) · 표준 · 총 속성 6개 · 표시 4개'
+}
+
+Table payment {
+  payment_id uniqueidentifier [pk, not null, note: '결제 ID']
+  order_id uniqueidentifier [not null, note: '주문 → orders']
+  amount money [not null, note: '금액']
+  Note: '결제 (Payment) · 표준 · 총 속성 8개 · 표시 3개'
+}
+
+TableGroup "고객" {
+  customer
+  address
+}
+
+TableGroup "상품" {
+  product
+  category
+}
+
+TableGroup "주문" {
+  orders
+  order_line
+  payment
+}
+
+Ref: address.customer_id > customer.customer_id
+Ref: product.category_id > category.category_id
+Ref: category.parent_id > category.category_id
+Ref: orders.customer_id > customer.customer_id
+Ref: orders.address_id > address.address_id
+Ref: order_line.order_id > orders.order_id
+Ref: order_line.product_id > product.product_id
+Ref: payment.order_id > orders.order_id

package/skills/erd-visual/fixtures/src-json/api.json

@@ -0,0 +1,38 @@
+{
+  "openapi": "3.0.0",
+  "info": { "title": "Demo API", "version": "1.0" },
+  "components": {
+    "schemas": {
+      "Customer": {
+        "type": "object",
+        "title": "고객",
+        "required": ["id", "name"],
+        "properties": {
+          "id": { "type": "string", "format": "uuid" },
+          "name": { "type": "string", "description": "고객명" },
+          "address": { "$ref": "#/components/schemas/Address" }
+        }
+      },
+      "Address": {
+        "type": "object",
+        "properties": {
+          "id": { "type": "string" },
+          "line1": { "type": "string" }
+        }
+      },
+      "Order": {
+        "type": "object",
+        "required": ["id"],
+        "properties": {
+          "id": { "type": "string" },
+          "customer": { "$ref": "#/components/schemas/Customer" },
+          "lines": { "type": "array", "items": { "$ref": "#/components/schemas/OrderLine" } }
+        }
+      },
+      "OrderLine": {
+        "type": "object",
+        "properties": { "sku": { "type": "string" }, "qty": { "type": "integer" } }
+      }
+    }
+  }
+}

package/skills/erd-visual/fixtures/src-prisma/schema.prisma

@@ -0,0 +1,44 @@
+// Prisma 판독기 회귀용. 함정: 목록 관계(그리면 안 됨) · fields 없는 관계 · enum · @@map
+generator client { provider = "prisma-client-js" }
+datasource db { provider = "postgresql"; url = env("DATABASE_URL") }
+
+enum Role { USER ADMIN }
+
+model User {
+  id        String   @id @default(uuid())
+  email     String   @unique
+  role      Role     @default(USER)
+  createdAt DateTime @default(now())
+  posts     Post[]                     // 목록 — FK 는 반대편에 있다. 여기선 안 그린다
+  profile   Profile?                   // fields 없음 — 컬럼 특정 불가
+  @@map("users")
+}
+
+model Profile {
+  id     String @id @default(uuid())
+  bio    String?
+  userId String @unique
+  user   User   @relation(fields: [userId], references: [id])
+}
+
+model Post {
+  id         String   @id @default(uuid())
+  title      String
+  authorId   String
+  author     User     @relation(fields: [authorId], references: [id])
+  categoryId String?
+  category   Category? @relation(fields: [categoryId], references: [id])
+  tags       Tag[]
+}
+
+model Category {
+  id    String @id @default(uuid())
+  name  String
+  posts Post[]
+}
+
+model Tag {
+  id    String @id @default(uuid())
+  name  String
+  posts Post[]
+}

package/skills/erd-visual/fixtures/src-sql/shop.sql

@@ -0,0 +1,62 @@
+-- 판독기 회귀용 DDL. 까다로운 것만 모았다.
+--   · 인라인 REFERENCES · 테이블 레벨 FOREIGN KEY · ALTER TABLE ADD CONSTRAINT
+--   · 복합 PK · 스키마 접두 · 따옴표/백틱 식별자 · 자기참조
+--   · 정의 없는 테이블 참조(스텁) · 주석 안의 가짜 FK
+
+CREATE SCHEMA sales;
+
+CREATE TABLE sales.customer (
+    customer_id   uuid          NOT NULL,
+    name          varchar(80)   NOT NULL,
+    email         varchar(160),
+    referred_by   uuid          REFERENCES sales.customer(customer_id),  -- 자기참조
+    CONSTRAINT pk_customer PRIMARY KEY (customer_id)
+);
+COMMENT ON TABLE sales.customer IS '고객';
+COMMENT ON COLUMN sales.customer.email IS '이메일';
+
+CREATE TABLE sales."order" (
+    order_id    uuid        NOT NULL PRIMARY KEY,
+    customer_id uuid        NOT NULL,
+    /* 아래 주석 안의 FOREIGN KEY 는 읽으면 안 된다:
+       FOREIGN KEY (ghost_col) REFERENCES ghost_never(id) */
+    placed_at   timestamp   NOT NULL,
+    coupon_id   uuid,
+    FOREIGN KEY (customer_id) REFERENCES sales.customer (customer_id)
+);
+COMMENT ON TABLE sales."order" IS '주문';
+
+CREATE TABLE IF NOT EXISTS sales.order_line (
+    order_id    uuid    NOT NULL,
+    line_no     int     NOT NULL,
+    product_id  uuid    NOT NULL,
+    qty         int     NOT NULL DEFAULT 1,
+    PRIMARY KEY (order_id, line_no),
+    CONSTRAINT fk_line_order   FOREIGN KEY (order_id)   REFERENCES sales."order"(order_id),
+    CONSTRAINT fk_line_product FOREIGN KEY (product_id) REFERENCES catalog.product(product_id)
+);
+COMMENT ON TABLE sales.order_line IS '주문 상세';
+
+CREATE TABLE catalog.product (
+    `product_id`  uuid          NOT NULL PRIMARY KEY,
+    `name`        varchar(160)  NOT NULL,
+    category_id   uuid
+);
+COMMENT ON TABLE catalog.product IS '상품';
+
+CREATE TABLE catalog.category (
+    category_id uuid NOT NULL PRIMARY KEY,
+    name        varchar(80) NOT NULL,
+    parent_id   uuid
+);
+COMMENT ON TABLE catalog.category IS '분류';
+
+ALTER TABLE ONLY catalog.product
+    ADD CONSTRAINT fk_product_category FOREIGN KEY (category_id) REFERENCES catalog.category(category_id);
+
+ALTER TABLE catalog.category
+    ADD CONSTRAINT fk_category_parent FOREIGN KEY (parent_id) REFERENCES catalog.category(category_id);
+
+-- 정의가 없는 테이블을 가리킨다 -> 스텁으로 남아야 한다
+ALTER TABLE sales."order"
+    ADD CONSTRAINT fk_order_coupon FOREIGN KEY (coupon_id) REFERENCES promo.coupon(coupon_id);

package/skills/erd-visual/readers/csv.mjs

@@ -0,0 +1,81 @@
+/* CSV 판독기 — xlsx 와 같은 원칙.
+ * CSV 에도 외래키 개념이 없다. 매핑이 없으면 구조만 보고한다.
+ */
+
+import { emptyIR } from './index.mjs';
+import { applyMap } from './xlsx.mjs';
+
+/** RFC4180 — 따옴표 안의 구분자·줄바꿈을 지킨다 */
+export function parseCsv(text, delim) {
+  const src = text.replace(/^\uFEFF/, '');
+  if (!delim) {
+    const head = src.slice(0, 4000);
+    const counts = [[',', 0], [';', 0], ['\t', 0], ['|', 0]]
+      .map(([d]) => [d, (head.match(new RegExp('\\' + d, 'g')) || []).length]);
+    counts.sort((a, b) => b[1] - a[1]);
+    delim = counts[0][1] ? counts[0][0] : ',';
+  }
+  const rows = [];
+  let row = [], cur = '', q = false;
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i];
+    if (q) {
+      if (c === '"') {
+        if (src[i + 1] === '"') { cur += '"'; i++; }
+        else q = false;
+      } else cur += c;
+      continue;
+    }
+    if (c === '"') { q = true; continue; }
+    if (c === delim) { row.push(cur); cur = ''; continue; }
+    if (c === '\r') continue;
+    if (c === '\n') { row.push(cur); rows.push(row); row = []; cur = ''; continue; }
+    cur += c;
+  }
+  if (cur !== '' || row.length) { row.push(cur); rows.push(row); }
+  return { rows: rows.filter(r => r.some(v => String(v).trim() !== '')), delim };
+}
+
+/** 0-based 인덱스를 스프레드시트 열 이름으로 (0 -> A, 26 -> AA) */
+export function colName(i) {
+  let s = '';
+  i += 1;
+  while (i > 0) { const r = (i - 1) % 26; s = String.fromCharCode(65 + r) + s; i = Math.floor((i - 1) / 26); }
+  return s;
+}
+
+export function readCsv(text, source = 'input.csv', opt = {}) {
+  const ir = emptyIR(source, 'csv');
+  const { rows, delim } = parseCsv(text, opt.delim);
+  if (!rows.length) { ir.warnings.push('빈 파일입니다'); return ir; }
+
+  // xlsx 와 같은 { A: '값' } 형태로 맞춰 매핑 로직을 공유한다
+  const asObj = rows.map(r => {
+    const o = {};
+    r.forEach((v, i) => { o[colName(i)] = String(v).trim(); });
+    return o;
+  });
+  const header = asObj[0];
+  const sheet = {
+    name: source.replace(/\.[^.]+$/, ''),
+    rows: asObj.length,
+    dataRows: asObj.length - 1,
+    columns: Object.keys(header)
+      .sort((a, b) => a.length - b.length || (a < b ? -1 : 1))
+      .map(c => ({ col: c, header: header[c] || '' })),
+    sample: asObj.slice(1, 4),
+    all: asObj,
+    delim,
+  };
+  ir.sheets = [sheet];
+
+  if (!opt.map) {
+    ir.needsMapping = true;
+    ir.warnings.push('CSV 에는 외래키 정보가 없습니다. 매핑을 줘야 테이블·관계를 뽑습니다 '
+      + '(구분자 "' + (delim === '\t' ? 'TAB' : delim) + '" · 데이터 ' + sheet.dataRows + '행 · 열 '
+      + sheet.columns.length + '개)');
+    return ir;
+  }
+  applyMap(ir, [sheet], opt.map);
+  return ir;
+}

package/skills/erd-visual/readers/index.mjs

@@ -0,0 +1,55 @@
+/* 판독기 공통 계약
+ *
+ * 판독기는 '파싱'만 한다. "이 시트의 어느 열이 관계 근거인가" 같은 판단은
+ * 스킬(SKILL.md 절차)이 한다. 판독기가 알아서 다 해주는 것처럼 만들면
+ * 근거 없는 관계가 조용히 섞인다.
+ *
+ * 모든 판독기는 아래 IR 을 돌려준다.
+ *
+ *   {
+ *     source: 'orders.sql',
+ *     format: 'sql',
+ *     tables: [{
+ *       name, label?, group?,
+ *       columns: [{ name, type, pk, notNull, note? }],
+ *     }],
+ *     refs: [{
+ *       from, col, to, toCol,
+ *       evidence: '원본에서 이 관계를 뒷받침한 문자열 그대로',
+ *       confidence: 'fact' | 'estimate',
+ *     }],
+ *     warnings: ['읽지 못한 것'],
+ *     unparsed: ['통째로 건너뛴 원문 조각'],
+ *   }
+ *
+ * evidence 는 비워 두지 않는다. 1:1 대조 검사가 이걸로 돈다.
+ * confidence 가 'estimate' 인 관계는 --infer 없이는 Ref 로 나가지 않는다.
+ */
+
+import { readSql } from './sql.mjs';
+import { readXlsx } from './xlsx.mjs';
+import { readCsv } from './csv.mjs';
+import { readXml } from './xml.mjs';
+import { readPrisma } from './prisma.mjs';
+import { readJsonSchema } from './jsonschema.mjs';
+
+export const READERS = [
+  { format: 'sql', ext: ['.sql', '.ddl'], read: readSql },
+  { format: 'xlsx', ext: ['.xlsx', '.xlsm'], read: readXlsx, binary: true },
+  { format: 'csv', ext: ['.csv', '.tsv'], read: readCsv },
+  { format: 'xml', ext: ['.xml'], read: readXml },
+  { format: 'prisma', ext: ['.prisma'], read: readPrisma },
+  { format: 'jsonschema', ext: ['.json', '.yaml', '.yml'], read: readJsonSchema },
+];
+
+export function detect(file) {
+  const lower = file.toLowerCase();
+  for (const r of READERS) {
+    if (r.ext.some(e => lower.endsWith(e))) return r;
+  }
+  return null;
+}
+
+export function emptyIR(source, format) {
+  return { source, format, tables: [], refs: [], warnings: [], unparsed: [] };
+}

package/skills/erd-visual/readers/jsonschema.mjs

@@ -0,0 +1,86 @@
+/* JSON Schema · OpenAPI 판독기.
+ *
+ * 주의: 이 형식은 **API 응답 모양**을 기술한다. 테이블도 외래키도 아니다.
+ * `$ref` 로 스키마 간 참조는 뽑을 수 있지만 그게 DB 관계라는 보장이 없다.
+ * 그래서 여기서 나오는 관계는 전부 confidence:'estimate' 다.
+ * --infer 없이는 Ref 로 나가지 않고 report 의 확인 목록으로만 간다.
+ */
+
+import { emptyIR } from './index.mjs';
+
+const typeOf = s => {
+  if (!s || typeof s !== 'object') return 'unknown';
+  if (s.$ref) return 'ref';
+  if (Array.isArray(s.type)) return s.type.filter(t => t !== 'null')[0] || 'unknown';
+  if (s.type) return s.type + (s.format ? '(' + s.format + ')' : '');
+  if (s.enum) return 'enum';
+  if (s.oneOf || s.anyOf || s.allOf) return 'composed';
+  return 'unknown';
+};
+
+const refName = r => String(r).split('/').pop();
+
+export function readJsonSchema(text, source = 'schema.json') {
+  const ir = emptyIR(source, 'jsonschema');
+  let doc;
+  try { doc = JSON.parse(text); }
+  catch (err) { ir.warnings.push('JSON 파싱 실패: ' + err.message); return ir; }
+
+  // OpenAPI 3 · Swagger 2 · 순수 JSON Schema 의 정의 위치
+  const defs = doc.components?.schemas || doc.definitions || doc.$defs ||
+    (doc.type === 'object' && doc.properties ? { [doc.title || 'root']: doc } : null);
+  if (!defs) {
+    ir.warnings.push('스키마 정의를 찾지 못했습니다 (components.schemas · definitions · $defs)');
+    return ir;
+  }
+
+  const isObj = s => s && typeof s === 'object' &&
+    (s.type === 'object' || s.properties || s.allOf || s.$ref);
+
+  for (const [name, schema] of Object.entries(defs)) {
+    if (!isObj(schema)) continue;
+    const t = { name, label: schema.title || name, group: null, columns: [] };
+    const required = new Set(schema.required || []);
+
+    // allOf 를 얕게 펼친다 (상속 표현으로 흔히 쓴다)
+    const props = { ...(schema.properties || {}) };
+    for (const part of schema.allOf || []) {
+      if (part.properties) Object.assign(props, part.properties);
+      if (part.$ref) {
+        ir.refs.push({
+          from: name, col: '(allOf)', to: refName(part.$ref), toCol: null,
+          evidence: 'allOf: ' + part.$ref, confidence: 'estimate',
+        });
+      }
+    }
+
+    for (const [pname, p] of Object.entries(props)) {
+      const isArr = p && p.type === 'array';
+      const inner = isArr ? (p.items || {}) : (p || {});
+      t.columns.push({
+        name: pname,
+        type: typeOf(inner) + (isArr ? '[]' : ''),
+        pk: /^id$/i.test(pname),
+        notNull: required.has(pname),
+        note: (p && (p.description || p.title)) || pname,
+      });
+      if (inner && inner.$ref) {
+        ir.refs.push({
+          from: name, col: pname, to: refName(inner.$ref), toCol: null,
+          evidence: pname + '.$ref = ' + inner.$ref,
+          confidence: 'estimate',
+        });
+      }
+    }
+    ir.tables.push(t);
+  }
+
+  const known = new Set(ir.tables.map(t => t.name));
+  for (const r of ir.refs) if (!known.has(r.to)) r.missingTarget = true;
+
+  if (!ir.tables.length) ir.warnings.push('객체 스키마를 하나도 찾지 못했습니다');
+  if (ir.refs.length)
+    ir.warnings.push('이 형식의 참조 ' + ir.refs.length + '건은 전부 추정입니다 — '
+      + 'API 응답 구조이지 DB 외래키가 아닙니다. --infer 로만 Ref 가 됩니다');
+  return ir;
+}

package/skills/erd-visual/readers/prisma.mjs

@@ -0,0 +1,102 @@
+/* Prisma schema 판독기.
+ *
+ * Prisma 는 관계를 선언으로 갖고 있어 근거가 명확하다 (confidence:'fact').
+ *   author  User @relation(fields:[authorId], references:[id])
+ * 스칼라 필드가 실제 외래키 컬럼이고, 관계 필드는 그 컬럼을 가리킨다.
+ * 관계 필드만 보고 선을 그으면 어느 컬럼이 FK 인지 잃어버린다.
+ */
+
+import { emptyIR } from './index.mjs';
+
+const stripComments = s => s.replace(/\/\/[^\n]*/g, '');
+
+const SCALARS = new Set(['String', 'Boolean', 'Int', 'BigInt', 'Float', 'Decimal',
+  'DateTime', 'Json', 'Bytes', 'Unsupported']);
+
+export function readPrisma(src, source = 'schema.prisma') {
+  const ir = emptyIR(source, 'prisma');
+  const text = stripComments(src);
+
+  const enums = new Set();
+  let e;
+  const reEnum = /^\s*enum\s+(\w+)\s*\{/gm;
+  while ((e = reEnum.exec(text))) enums.add(e[1]);
+
+  const models = new Map();
+  const reModel = /^\s*model\s+(\w+)\s*\{([\s\S]*?)^\s*\}/gm;
+  let m;
+  while ((m = reModel.exec(text))) {
+    const name = m[1], body = m[2];
+    const t = { name, label: name, group: null, columns: [] };
+    const rels = [];
+
+    for (const raw of body.split('\n')) {
+      const line = raw.trim();
+      if (!line || line.startsWith('@@')) {
+        // @@map("table_name") — 실제 테이블명
+        const mm = line.match(/@@map\("([^"]+)"\)/);
+        if (mm) t.mapped = mm[1];
+        const idm = line.match(/@@id\(\s*\[([^\]]+)\]/);
+        if (idm) t.compositeId = idm[1].split(',').map(s => s.trim());
+        continue;
+      }
+      const fm = line.match(/^(\w+)\s+(\w+)(\[\])?(\?)?\s*(.*)$/);
+      if (!fm) continue;
+      const [, fname, ftype, isList, optional, attrs] = fm;
+
+      const relm = attrs.match(/@relation\(([^)]*)\)/);
+      const isScalar = SCALARS.has(ftype) || enums.has(ftype);
+
+      if (isScalar) {
+        t.columns.push({
+          name: fname,
+          type: ftype + (isList ? '[]' : ''),
+          pk: /@id\b/.test(attrs),
+          notNull: !optional && !isList,
+          note: (attrs.match(/@map\("([^"]+)"\)/) || [, ''])[1] || fname,
+        });
+        continue;
+      }
+
+      // 관계 필드 — 목록(1:N 의 N쪽)은 상대편에 FK 가 있으므로 여기선 그리지 않는다
+      if (isList) continue;
+      if (!relm) {
+        // @relation 없는 단일 관계 — FK 컬럼을 특정할 수 없다
+        rels.push({ target: ftype, fields: null, refs: null, raw: line });
+        continue;
+      }
+      const fields = (relm[1].match(/fields\s*:\s*\[([^\]]*)\]/) || [, ''])[1]
+        .split(',').map(s => s.trim()).filter(Boolean);
+      const refs = (relm[1].match(/references\s*:\s*\[([^\]]*)\]/) || [, ''])[1]
+        .split(',').map(s => s.trim()).filter(Boolean);
+      rels.push({ target: ftype, fields, refs, raw: line });
+    }
+
+    models.set(name, { t, rels });
+  }
+
+  for (const { t } of models.values()) ir.tables.push(t);
+
+  for (const { t, rels } of models.values()) {
+    for (const r of rels) {
+      if (!models.has(r.target)) {
+        ir.warnings.push(t.name + ': 모델을 찾지 못한 관계 대상 ' + r.target);
+        continue;
+      }
+      if (!r.fields || !r.fields.length) {
+        ir.warnings.push(t.name + ' → ' + r.target +
+          ': @relation 에 fields 가 없어 외래키 컬럼을 특정할 수 없습니다 (Ref 로 그리지 않음)');
+        continue;
+      }
+      r.fields.forEach((f, i) => {
+        ir.refs.push({
+          from: t.name, col: f, to: r.target, toCol: (r.refs && r.refs[i]) || null,
+          evidence: r.raw, confidence: 'fact',
+        });
+      });
+    }
+  }
+
+  if (!ir.tables.length) ir.warnings.push('model 블록을 찾지 못했습니다');
+  return ir;
+}